Add metrics for seidb

Author: yzang2019

common/metrics/metrics.go

@@ -1,11 +1,8 @@
 package metrics
 
 import (
-	"fmt"
 	"go.opentelemetry.io/otel"
-	"go.opentelemetry.io/otel/exporters/prometheus"
 	"go.opentelemetry.io/otel/metric"
-	sdk "go.opentelemetry.io/otel/sdk/metric"
 )
 
 var (
@@ -16,8 +13,8 @@ var (
 		SnapshotCreationLatency metric.Float64Histogram
 		CommitLatency           metric.Int64Histogram
 		ApplyChangesetLatency   metric.Int64Histogram
-		MemNodeTotalSize        metric.Float64Gauge
-		MemNodeCount            metric.Float64Gauge
+		MemNodeTotalSize        metric.Int64Gauge
+		NumOfMemNode            metric.Int64Gauge
 	}{
 		RestartLatency: must(meter.Float64Histogram(
 			"restart_latency",
@@ -36,18 +33,18 @@ var (
 		)),
 		ApplyChangesetLatency: must(meter.Int64Histogram(
 			"apply_changeset_latency",
-			metric.WithDescription("Time taken to commit"),
+			metric.WithDescription("Time taken to apply changesets"),
 			metric.WithUnit("ms"),
 		)),
-		MemNodeTotalSize: must(meter.Float64Gauge(
+		MemNodeTotalSize: must(meter.Int64Gauge(
 			"mem_node_total_size",
-			metric.WithDescription("Time taken to restart the memiavl database"),
-			metric.WithUnit("s"),
+			metric.WithDescription("Total size of memnodes"),
+			metric.WithUnit("By"),
 		)),
-		MemNodeCount: must(meter.Float64Gauge(
+		NumOfMemNode: must(meter.Int64Gauge(
 			"mem_node_count",
-			metric.WithDescription("Time taken to restart the memiavl database"),
-			metric.WithUnit("s"),
+			metric.WithDescription("Total number of mem nodes"),
+			metric.WithUnit("{count}"),
 		)),
 	}
 )
@@ -59,12 +56,3 @@ func must[V any](v V, err error) V {
 	}
 	return v
 }
-
-func SetupMetricsProvider() error {
-	metricsExporter, err := prometheus.New(prometheus.WithNamespace("seidb"))
-	if err != nil {
-		return fmt.Errorf("failed to create Prometheus exporter: %w", err)
-	}
-	otel.SetMeterProvider(sdk.NewMeterProvider(sdk.WithReader(metricsExporter)))
-	return nil
-}

sc/memiavl/db.go

@@ -396,9 +396,12 @@ func (db *DB) checkBackgroundSnapshotRewrite() error {
 		if err := db.reloadMultiTree(result.mtree); err != nil {
 			return fmt.Errorf("switch multitree failed: %w", err)
 		}
+		// reset memnode counter
+		TotalMemNodeSize.Store(0)
+		TotalNumOfMemNode.Store(0)
 		db.logger.Info("switched to new memiavl snapshot", "version", db.MultiTree.Version())
-
 		db.pruneSnapshots()
+
 	default:
 	}
 
@@ -462,7 +465,11 @@ func (db *DB) Commit() (int64, error) {
 	defer db.mtx.Unlock()
 	startTime := time.Now()
 	defer func() {
+
 		metrics.SeiDBMetrics.CommitLatency.Record(context.Background(), time.Since(startTime).Milliseconds())
+		metrics.SeiDBMetrics.MemNodeTotalSize.Record(context.Background(), TotalMemNodeSize.Load())
+		metrics.SeiDBMetrics.NumOfMemNode.Record(context.Background(), TotalNumOfMemNode.Load())
+
 	}()
 	if db.readOnly {
 		return 0, errReadOnly
@@ -605,7 +612,10 @@ func (db *DB) rewriteSnapshotBackground() error {
 	cloned := db.copy(0)
 	go func() {
 		defer close(ch)
-
+		startTime := time.Now()
+		defer func() {
+			metrics.SeiDBMetrics.SnapshotCreationLatency.Record(context.Background(), time.Since(startTime).Seconds())
+		}()
 		cloned.logger.Info("start rewriting snapshot", "version", cloned.Version())
 		if err := cloned.RewriteSnapshot(ctx); err != nil {
 			ch <- snapshotResult{err: err}

sc/memiavl/mem_node.go

@@ -4,12 +4,13 @@ import (
 	"bytes"
 	"encoding/binary"
 	"io"
+	"sync/atomic"
 )
 
 type MemNode struct {
 	height  uint8
-	size    int64
 	version uint32
+	size    int64
 	key     []byte
 	value   []byte
 	left    Node
@@ -18,8 +19,33 @@ type MemNode struct {
 }
 
 var _ Node = (*MemNode)(nil)
+var (
+	TotalMemNodeSize  = atomic.Int64{}
+	TotalNumOfMemNode = atomic.Int64{}
+)
+
+func newBranchNode(
+	height uint8,
+	size int64,
+	version uint32,
+	key []byte,
+	left Node,
+	right Node) *MemNode {
+	TotalNumOfMemNode.Add(1)
+	TotalMemNodeSize.Add(int64(120 + len(key)))
+	return &MemNode{
+		height:  height,
+		size:    size,
+		version: version,
+		key:     key,
+		left:    left,
+		right:   right,
+	}
+}
 
 func newLeafNode(key, value []byte, version uint32) *MemNode {
+	TotalNumOfMemNode.Add(1)
+	TotalMemNodeSize.Add(int64(120 + len(key) + len(value)))
 	return &MemNode{
 		key: key, value: value, version: version, size: 1,
 	}

sc/memiavl/node.go

@@ -43,23 +43,9 @@ func setRecursive(node Node, key, value []byte, version, cowVersion uint32) (*Me
 	if node.IsLeaf() {
 		switch bytes.Compare(key, nodeKey) {
 		case -1:
-			return &MemNode{
-				height:  1,
-				size:    2,
-				version: version,
-				key:     nodeKey,
-				left:    newLeafNode(key, value, version),
-				right:   node,
-			}, false
+			return newBranchNode(1, 2, version, nodeKey, newLeafNode(key, value, version), node), false
 		case 1:
-			return &MemNode{
-				height:  1,
-				size:    2,
-				version: version,
-				key:     key,
-				left:    node,
-				right:   newLeafNode(key, value, version),
-			}, false
+			return newBranchNode(1, 2, version, key, node, newLeafNode(key, value, version)), false
 		default:
 			newNode := node.Mutate(version, cowVersion)
 			newNode.value = value

sc/memiavl/persisted_node.go

@@ -147,23 +147,10 @@ func (node PersistedNode) Hash() []byte {
 func (node PersistedNode) Mutate(version, _ uint32) *MemNode {
 	if node.isLeaf {
 		key, value := node.snapshot.LeafKeyValue(node.index)
-		return &MemNode{
-			height:  0,
-			size:    1,
-			version: version,
-			key:     key,
-			value:   value,
-		}
+		return newLeafNode(key, value, version)
 	}
 	data := node.branchNode()
-	return &MemNode{
-		height:  data.Height(),
-		size:    int64(data.Size()),
-		version: version,
-		key:     node.Key(),
-		left:    node.Left(),
-		right:   node.Right(),
-	}
+	return newBranchNode(data.Height(), int64(data.Size()), version, node.Key(), node.Left(), node.Right())
 }
 
 func (node PersistedNode) Get(key []byte) ([]byte, uint32) {