update

Author: guandali

metrics/client.go

@@ -15,44 +15,39 @@ import (
 )
 
 var (
-	// RPCCallLatency measures RPC duration in milliseconds (bucket upper bounds from 50 ms to 8 s).
-	// Values are latency.Seconds()*1000, not float64(duration) — the latter is nanoseconds and will skew quantiles.
 	RPCCallLatency = promauto.NewHistogramVec(prometheus.HistogramOpts{
 		Name: rpcCallLatencyBeholder,
-		Help: "The duration of an RPC call in milliseconds",
+		Help: "The duration of an RPC call in nanoseconds",
 		Buckets: []float64{
-			50, 100, 200, 500,
-			1000, 2000, 4000, 8000,
+			float64(50 * time.Millisecond),
+			float64(100 * time.Millisecond),
+			float64(200 * time.Millisecond),
+			float64(500 * time.Millisecond),
+			float64(1 * time.Second),
+			float64(2 * time.Second),
+			float64(4 * time.Second),
+			float64(8 * time.Second),
 		},
 	}, []string{"chainFamily", "chainID", "rpcUrl", "isSendOnly", "success", "rpcCallName"})
-
-	RPCCallErrorsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
-		Name: "rpc_call_errors_total",
-		Help: "The total number of failed RPC calls",
-	}, []string{"chainFamily", "chainID", "rpcUrl", "isSendOnly", "rpcCallName"})
 )
 
-const (
-	rpcCallLatencyBeholder     = "rpc_call_latency"
-	rpcCallErrorsTotalBeholder = "rpc_call_errors_total"
-)
+const rpcCallLatencyBeholder = "rpc_call_latency"
 
-// RPCClientMetrics records RPC latency and errors to Prometheus and Beholder (same pattern as multinode metrics).
+// RPCClientMetrics records RPC call latency to Prometheus and Beholder (failures: success="false"; same pattern as multinode metrics).
 // Construct once per chain (or process) with ChainFamily and ChainID; pass rpcUrl and isSendOnly on each call
 // when they vary by node or request.
 type RPCClientMetrics interface {
-	// RecordRequest records latency for an RPC call (observed in milliseconds for Prometheus and Beholder).
-	// If err is non-nil, increments rpc_call_errors_total.
+	// RecordRequest records latency for an RPC call (observed in nanoseconds for Prometheus and Beholder).
+	// Failures use success="false"; derive error rate from rpc_call_latency_count{success="false"} (or equivalent).
 	RecordRequest(ctx context.Context, rpcURL string, isSendOnly bool, callName string, latency time.Duration, err error)
 }
 
 var _ RPCClientMetrics = (*rpcClientMetrics)(nil)
 
 type rpcClientMetrics struct {
-	chainFamily   string
-	chainID       string
-	latencyHis    metric.Float64Histogram
-	errorsCounter metric.Int64Counter
+	chainFamily string
+	chainID     string
+	latencyHis  metric.Float64Histogram
 }
 
 // RPCClientMetricsConfig holds labels that are fixed for the lifetime of the metrics handle (e.g. one per chain).
@@ -67,15 +62,10 @@ func NewRPCClientMetrics(cfg RPCClientMetricsConfig) (RPCClientMetrics, error) {
 	if err != nil {
 		return nil, fmt.Errorf("failed to register RPC call latency metric: %w", err)
 	}
-	errorsTotal, err := beholder.GetMeter().Int64Counter(rpcCallErrorsTotalBeholder)
-	if err != nil {
-		return nil, fmt.Errorf("failed to register RPC call errors metric: %w", err)
-	}
 	return &rpcClientMetrics{
-		chainFamily:   cfg.ChainFamily,
-		chainID:       cfg.ChainID,
-		latencyHis:    latency,
-		errorsCounter: errorsTotal,
+		chainFamily: cfg.ChainFamily,
+		chainID:     cfg.ChainID,
+		latencyHis:  latency,
 	}, nil
 }
 
@@ -85,9 +75,9 @@ func (m *rpcClientMetrics) RecordRequest(ctx context.Context, rpcURL string, isS
 		successStr = "false"
 	}
 	sendStr := strconv.FormatBool(isSendOnly)
-	ms := latency.Seconds() * 1000
+	latencyNs := float64(latency)
 
-	RPCCallLatency.WithLabelValues(m.chainFamily, m.chainID, rpcURL, sendStr, successStr, callName).Observe(ms)
+	RPCCallLatency.WithLabelValues(m.chainFamily, m.chainID, rpcURL, sendStr, successStr, callName).Observe(latencyNs)
 
 	latAttrs := metric.WithAttributes(
 		attribute.String("chainFamily", m.chainFamily),
@@ -97,19 +87,7 @@ func (m *rpcClientMetrics) RecordRequest(ctx context.Context, rpcURL string, isS
 		attribute.String("success", successStr),
 		attribute.String("rpcCallName", callName),
 	)
-	m.latencyHis.Record(ctx, ms, latAttrs)
-
-	if err != nil {
-		RPCCallErrorsTotal.WithLabelValues(m.chainFamily, m.chainID, rpcURL, sendStr, callName).Inc()
-		errAttrs := metric.WithAttributes(
-			attribute.String("chainFamily", m.chainFamily),
-			attribute.String("chainID", m.chainID),
-			attribute.String("rpcUrl", rpcURL),
-			attribute.String("isSendOnly", sendStr),
-			attribute.String("rpcCallName", callName),
-		)
-		m.errorsCounter.Add(ctx, 1, errAttrs)
-	}
+	m.latencyHis.Record(ctx, latencyNs, latAttrs)
 }
 
 // NoopRPCClientMetrics is a no-op implementation for when metrics are disabled.