629 lines
19 KiB
Go
629 lines
19 KiB
Go
package proxyd
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
"github.com/prometheus/client_golang/prometheus/promauto"
|
|
)
|
|
|
|
const (
|
|
MetricsNamespace = "proxyd"
|
|
|
|
RPCRequestSourceHTTP = "http"
|
|
RPCRequestSourceWS = "ws"
|
|
|
|
BackendProxyd = "proxyd"
|
|
SourceClient = "client"
|
|
SourceBackend = "backend"
|
|
MethodUnknown = "unknown"
|
|
)
|
|
|
|
var PayloadSizeBuckets = []float64{10, 50, 100, 500, 1000, 5000, 10000, 100000, 1000000}
|
|
var MillisecondDurationBuckets = []float64{1, 10, 50, 100, 500, 1000, 5000, 10000, 100000}
|
|
|
|
var (
|
|
rpcRequestsTotal = promauto.NewCounter(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "rpc_requests_total",
|
|
Help: "Count of total client RPC requests.",
|
|
})
|
|
|
|
rpcForwardsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "rpc_forwards_total",
|
|
Help: "Count of total RPC requests forwarded to each backend.",
|
|
}, []string{
|
|
"auth",
|
|
"backend_name",
|
|
"method_name",
|
|
"source",
|
|
})
|
|
|
|
rpcBackendHTTPResponseCodesTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "rpc_backend_http_response_codes_total",
|
|
Help: "Count of total backend responses by HTTP status code.",
|
|
}, []string{
|
|
"auth",
|
|
"backend_name",
|
|
"method_name",
|
|
"status_code",
|
|
"batched",
|
|
})
|
|
|
|
rpcErrorsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "rpc_errors_total",
|
|
Help: "Count of total RPC errors.",
|
|
}, []string{
|
|
"auth",
|
|
"backend_name",
|
|
"method_name",
|
|
"error_code",
|
|
})
|
|
|
|
rpcSpecialErrorsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "rpc_special_errors_total",
|
|
Help: "Count of total special RPC errors.",
|
|
}, []string{
|
|
"auth",
|
|
"backend_name",
|
|
"method_name",
|
|
"error_type",
|
|
})
|
|
|
|
rpcBackendRequestDurationSumm = promauto.NewSummaryVec(prometheus.SummaryOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "rpc_backend_request_duration_seconds",
|
|
Help: "Summary of backend response times broken down by backend and method name.",
|
|
Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.95: 0.005, 0.99: 0.001},
|
|
}, []string{
|
|
"backend_name",
|
|
"method_name",
|
|
"batched",
|
|
})
|
|
|
|
activeClientWsConnsGauge = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "active_client_ws_conns",
|
|
Help: "Gauge of active client WS connections.",
|
|
}, []string{
|
|
"auth",
|
|
})
|
|
|
|
activeBackendWsConnsGauge = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "active_backend_ws_conns",
|
|
Help: "Gauge of active backend WS connections.",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
unserviceableRequestsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "unserviceable_requests_total",
|
|
Help: "Count of total requests that were rejected due to no backends being available.",
|
|
}, []string{
|
|
"auth",
|
|
"request_source",
|
|
})
|
|
|
|
httpResponseCodesTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "http_response_codes_total",
|
|
Help: "Count of total HTTP response codes.",
|
|
}, []string{
|
|
"status_code",
|
|
})
|
|
|
|
httpRequestDurationSumm = promauto.NewSummary(prometheus.SummaryOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "http_request_duration_seconds",
|
|
Help: "Summary of HTTP request durations, in seconds.",
|
|
Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.95: 0.005, 0.99: 0.001},
|
|
})
|
|
|
|
wsMessagesTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "ws_messages_total",
|
|
Help: "Count of total websocket messages including protocol control.",
|
|
}, []string{
|
|
"auth",
|
|
"backend_name",
|
|
"source",
|
|
})
|
|
|
|
redisErrorsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "redis_errors_total",
|
|
Help: "Count of total Redis errors.",
|
|
}, []string{
|
|
"source",
|
|
})
|
|
|
|
requestPayloadSizesGauge = promauto.NewHistogramVec(prometheus.HistogramOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "request_payload_sizes",
|
|
Help: "Histogram of client request payload sizes.",
|
|
Buckets: PayloadSizeBuckets,
|
|
}, []string{
|
|
"auth",
|
|
})
|
|
|
|
responsePayloadSizesGauge = promauto.NewHistogramVec(prometheus.HistogramOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "response_payload_sizes",
|
|
Help: "Histogram of client response payload sizes.",
|
|
Buckets: PayloadSizeBuckets,
|
|
}, []string{
|
|
"auth",
|
|
})
|
|
|
|
cacheHitsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "cache_hits_total",
|
|
Help: "Number of cache hits.",
|
|
}, []string{
|
|
"method",
|
|
})
|
|
|
|
cacheMissesTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "cache_misses_total",
|
|
Help: "Number of cache misses.",
|
|
}, []string{
|
|
"method",
|
|
})
|
|
|
|
cacheErrorsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "cache_errors_total",
|
|
Help: "Number of cache errors.",
|
|
}, []string{
|
|
"method",
|
|
})
|
|
|
|
batchRPCShortCircuitsTotal = promauto.NewCounter(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "batch_rpc_short_circuits_total",
|
|
Help: "Count of total batch RPC short-circuits.",
|
|
})
|
|
|
|
rpcSpecialErrors = []string{
|
|
"nonce too low",
|
|
"gas price too high",
|
|
"gas price too low",
|
|
"invalid parameters",
|
|
}
|
|
|
|
redisCacheDurationSumm = promauto.NewHistogramVec(prometheus.HistogramOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "redis_cache_duration_milliseconds",
|
|
Help: "Histogram of Redis command durations, in milliseconds.",
|
|
Buckets: MillisecondDurationBuckets,
|
|
}, []string{"command"})
|
|
|
|
tooManyRequestErrorsTotal = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "too_many_request_errors_total",
|
|
Help: "Count of request timeouts due to too many concurrent RPCs.",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
batchSizeHistogram = promauto.NewHistogram(prometheus.HistogramOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "batch_size_summary",
|
|
Help: "Summary of batch sizes",
|
|
Buckets: []float64{
|
|
1,
|
|
5,
|
|
10,
|
|
25,
|
|
50,
|
|
100,
|
|
},
|
|
})
|
|
|
|
frontendRateLimitTakeErrors = promauto.NewCounter(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "rate_limit_take_errors",
|
|
Help: "Count of errors taking frontend rate limits",
|
|
})
|
|
|
|
consensusLatestBlock = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "group_consensus_latest_block",
|
|
Help: "Consensus latest block",
|
|
}, []string{
|
|
"backend_group_name",
|
|
})
|
|
|
|
consensusSafeBlock = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "group_consensus_safe_block",
|
|
Help: "Consensus safe block",
|
|
}, []string{
|
|
"backend_group_name",
|
|
})
|
|
|
|
consensusFinalizedBlock = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "group_consensus_finalized_block",
|
|
Help: "Consensus finalized block",
|
|
}, []string{
|
|
"backend_group_name",
|
|
})
|
|
|
|
consensusHAError = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "group_consensus_ha_error",
|
|
Help: "Consensus HA error count",
|
|
}, []string{
|
|
"error",
|
|
})
|
|
|
|
consensusHALatestBlock = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "group_consensus_ha_latest_block",
|
|
Help: "Consensus HA latest block",
|
|
}, []string{
|
|
"backend_group_name",
|
|
"leader",
|
|
})
|
|
|
|
consensusHASafeBlock = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "group_consensus_ha_safe_block",
|
|
Help: "Consensus HA safe block",
|
|
}, []string{
|
|
"backend_group_name",
|
|
"leader",
|
|
})
|
|
|
|
consensusHAFinalizedBlock = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "group_consensus_ha_finalized_block",
|
|
Help: "Consensus HA finalized block",
|
|
}, []string{
|
|
"backend_group_name",
|
|
"leader",
|
|
})
|
|
|
|
backendLatestBlockBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "backend_latest_block",
|
|
Help: "Current latest block observed per backend",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
backendSafeBlockBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "backend_safe_block",
|
|
Help: "Current safe block observed per backend",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
backendFinalizedBlockBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "backend_finalized_block",
|
|
Help: "Current finalized block observed per backend",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
backendUnexpectedBlockTagsBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "backend_unexpected_block_tags",
|
|
Help: "Bool gauge for unexpected block tags",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
consensusGroupCount = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "group_consensus_count",
|
|
Help: "Consensus group serving traffic count",
|
|
}, []string{
|
|
"backend_group_name",
|
|
})
|
|
|
|
consensusGroupFilteredCount = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "group_consensus_filtered_count",
|
|
Help: "Consensus group filtered out from serving traffic count",
|
|
}, []string{
|
|
"backend_group_name",
|
|
})
|
|
|
|
consensusGroupTotalCount = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "group_consensus_total_count",
|
|
Help: "Total count of candidates to be part of consensus group",
|
|
}, []string{
|
|
"backend_group_name",
|
|
})
|
|
|
|
consensusBannedBackends = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "consensus_backend_banned",
|
|
Help: "Bool gauge for banned backends",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
consensusPeerCountBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "consensus_backend_peer_count",
|
|
Help: "Peer count",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
consensusInSyncBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "consensus_backend_in_sync",
|
|
Help: "Bool gauge for backends in sync",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
consensusUpdateDelayBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "consensus_backend_update_delay",
|
|
Help: "Delay (ms) for backend update",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
avgLatencyBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "backend_avg_latency",
|
|
Help: "Average latency per backend",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
degradedBackends = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "backend_degraded",
|
|
Help: "Bool gauge for degraded backends",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
networkErrorRateBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "backend_error_rate",
|
|
Help: "Request error rate per backend",
|
|
}, []string{
|
|
"backend_name",
|
|
})
|
|
|
|
healthyPrimaryCandidates = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "healthy_candidates",
|
|
Help: "Record the number of healthy primary candidates",
|
|
}, []string{
|
|
"backend_group_name",
|
|
})
|
|
|
|
backendGroupFallbackBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "backend_group_fallback_backenend",
|
|
Help: "Bool gauge for if a backend is a fallback for a backend group",
|
|
}, []string{
|
|
"backend_group",
|
|
"backend_name",
|
|
"fallback",
|
|
})
|
|
|
|
backendGroupMulticallCounter = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "backend_group_multicall_request_counter",
|
|
Help: "Record the amount of multicall requests",
|
|
}, []string{
|
|
"backend_group",
|
|
"backend_name",
|
|
})
|
|
|
|
backendGroupMulticallCompletionCounter = promauto.NewCounterVec(prometheus.CounterOpts{
|
|
Namespace: MetricsNamespace,
|
|
Name: "backend_group_multicall_completion_counter",
|
|
Help: "Record the amount of completed multicall requests",
|
|
}, []string{
|
|
"backend_group",
|
|
"backend_name",
|
|
"error",
|
|
})
|
|
)
|
|
|
|
func RecordRedisError(source string) {
|
|
redisErrorsTotal.WithLabelValues(source).Inc()
|
|
}
|
|
|
|
func RecordRPCError(ctx context.Context, backendName, method string, err error) {
|
|
rpcErr, ok := err.(*RPCErr)
|
|
var code int
|
|
if ok {
|
|
MaybeRecordSpecialRPCError(ctx, backendName, method, rpcErr)
|
|
code = rpcErr.Code
|
|
} else {
|
|
code = -1
|
|
}
|
|
|
|
rpcErrorsTotal.WithLabelValues(GetAuthCtx(ctx), backendName, method, strconv.Itoa(code)).Inc()
|
|
}
|
|
|
|
func RecordWSMessage(ctx context.Context, backendName, source string) {
|
|
wsMessagesTotal.WithLabelValues(GetAuthCtx(ctx), backendName, source).Inc()
|
|
}
|
|
|
|
func RecordUnserviceableRequest(ctx context.Context, source string) {
|
|
unserviceableRequestsTotal.WithLabelValues(GetAuthCtx(ctx), source).Inc()
|
|
}
|
|
|
|
func RecordRPCForward(ctx context.Context, backendName, method, source string) {
|
|
rpcForwardsTotal.WithLabelValues(GetAuthCtx(ctx), backendName, method, source).Inc()
|
|
}
|
|
|
|
func MaybeRecordSpecialRPCError(ctx context.Context, backendName, method string, rpcErr *RPCErr) {
|
|
errMsg := strings.ToLower(rpcErr.Message)
|
|
for _, errStr := range rpcSpecialErrors {
|
|
if strings.Contains(errMsg, errStr) {
|
|
rpcSpecialErrorsTotal.WithLabelValues(GetAuthCtx(ctx), backendName, method, errStr).Inc()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func RecordRequestPayloadSize(ctx context.Context, payloadSize int) {
|
|
requestPayloadSizesGauge.WithLabelValues(GetAuthCtx(ctx)).Observe(float64(payloadSize))
|
|
}
|
|
|
|
func RecordResponsePayloadSize(ctx context.Context, payloadSize int) {
|
|
responsePayloadSizesGauge.WithLabelValues(GetAuthCtx(ctx)).Observe(float64(payloadSize))
|
|
}
|
|
|
|
func RecordCacheHit(method string) {
|
|
cacheHitsTotal.WithLabelValues(method).Inc()
|
|
}
|
|
|
|
func RecordCacheMiss(method string) {
|
|
cacheMissesTotal.WithLabelValues(method).Inc()
|
|
}
|
|
|
|
func RecordCacheError(method string) {
|
|
cacheErrorsTotal.WithLabelValues(method).Inc()
|
|
}
|
|
|
|
func RecordBatchSize(size int) {
|
|
batchSizeHistogram.Observe(float64(size))
|
|
}
|
|
|
|
var nonAlphanumericRegex = regexp.MustCompile(`[^a-zA-Z ]+`)
|
|
|
|
func RecordGroupConsensusError(group *BackendGroup, label string, err error) {
|
|
errClean := nonAlphanumericRegex.ReplaceAllString(err.Error(), "")
|
|
errClean = strings.ReplaceAll(errClean, " ", "_")
|
|
errClean = strings.ReplaceAll(errClean, "__", "_")
|
|
label = fmt.Sprintf("%s.%s", label, errClean)
|
|
consensusHAError.WithLabelValues(label).Inc()
|
|
}
|
|
|
|
func RecordGroupConsensusHALatestBlock(group *BackendGroup, leader string, blockNumber hexutil.Uint64) {
|
|
consensusHALatestBlock.WithLabelValues(group.Name, leader).Set(float64(blockNumber))
|
|
}
|
|
|
|
func RecordGroupConsensusHASafeBlock(group *BackendGroup, leader string, blockNumber hexutil.Uint64) {
|
|
consensusHASafeBlock.WithLabelValues(group.Name, leader).Set(float64(blockNumber))
|
|
}
|
|
|
|
func RecordGroupConsensusHAFinalizedBlock(group *BackendGroup, leader string, blockNumber hexutil.Uint64) {
|
|
consensusHAFinalizedBlock.WithLabelValues(group.Name, leader).Set(float64(blockNumber))
|
|
}
|
|
|
|
func RecordGroupConsensusLatestBlock(group *BackendGroup, blockNumber hexutil.Uint64) {
|
|
consensusLatestBlock.WithLabelValues(group.Name).Set(float64(blockNumber))
|
|
}
|
|
|
|
func RecordGroupConsensusSafeBlock(group *BackendGroup, blockNumber hexutil.Uint64) {
|
|
consensusSafeBlock.WithLabelValues(group.Name).Set(float64(blockNumber))
|
|
}
|
|
|
|
func RecordGroupConsensusFinalizedBlock(group *BackendGroup, blockNumber hexutil.Uint64) {
|
|
consensusFinalizedBlock.WithLabelValues(group.Name).Set(float64(blockNumber))
|
|
}
|
|
|
|
func RecordGroupConsensusCount(group *BackendGroup, count int) {
|
|
consensusGroupCount.WithLabelValues(group.Name).Set(float64(count))
|
|
}
|
|
|
|
func RecordGroupConsensusFilteredCount(group *BackendGroup, count int) {
|
|
consensusGroupFilteredCount.WithLabelValues(group.Name).Set(float64(count))
|
|
}
|
|
|
|
func RecordGroupTotalCount(group *BackendGroup, count int) {
|
|
consensusGroupTotalCount.WithLabelValues(group.Name).Set(float64(count))
|
|
}
|
|
|
|
func RecordBackendLatestBlock(b *Backend, blockNumber hexutil.Uint64) {
|
|
backendLatestBlockBackend.WithLabelValues(b.Name).Set(float64(blockNumber))
|
|
}
|
|
|
|
func RecordBackendSafeBlock(b *Backend, blockNumber hexutil.Uint64) {
|
|
backendSafeBlockBackend.WithLabelValues(b.Name).Set(float64(blockNumber))
|
|
}
|
|
|
|
func RecordBackendFinalizedBlock(b *Backend, blockNumber hexutil.Uint64) {
|
|
backendFinalizedBlockBackend.WithLabelValues(b.Name).Set(float64(blockNumber))
|
|
}
|
|
|
|
func RecordBackendUnexpectedBlockTags(b *Backend, unexpected bool) {
|
|
backendUnexpectedBlockTagsBackend.WithLabelValues(b.Name).Set(boolToFloat64(unexpected))
|
|
}
|
|
|
|
func RecordConsensusBackendBanned(b *Backend, banned bool) {
|
|
consensusBannedBackends.WithLabelValues(b.Name).Set(boolToFloat64(banned))
|
|
}
|
|
|
|
func RecordHealthyCandidates(b *BackendGroup, candidates int) {
|
|
healthyPrimaryCandidates.WithLabelValues(b.Name).Set(float64(candidates))
|
|
}
|
|
|
|
func RecordConsensusBackendPeerCount(b *Backend, peerCount uint64) {
|
|
consensusPeerCountBackend.WithLabelValues(b.Name).Set(float64(peerCount))
|
|
}
|
|
|
|
func RecordConsensusBackendInSync(b *Backend, inSync bool) {
|
|
consensusInSyncBackend.WithLabelValues(b.Name).Set(boolToFloat64(inSync))
|
|
}
|
|
|
|
func RecordConsensusBackendUpdateDelay(b *Backend, lastUpdate time.Time) {
|
|
// avoid recording the delay for the first update
|
|
if lastUpdate.IsZero() {
|
|
return
|
|
}
|
|
delay := time.Since(lastUpdate)
|
|
consensusUpdateDelayBackend.WithLabelValues(b.Name).Set(float64(delay.Milliseconds()))
|
|
}
|
|
|
|
func RecordBackendNetworkLatencyAverageSlidingWindow(b *Backend, avgLatency time.Duration) {
|
|
avgLatencyBackend.WithLabelValues(b.Name).Set(float64(avgLatency.Milliseconds()))
|
|
degradedBackends.WithLabelValues(b.Name).Set(boolToFloat64(b.IsDegraded()))
|
|
}
|
|
|
|
func RecordBackendNetworkErrorRateSlidingWindow(b *Backend, rate float64) {
|
|
networkErrorRateBackend.WithLabelValues(b.Name).Set(rate)
|
|
}
|
|
|
|
func RecordBackendGroupFallbacks(bg *BackendGroup, name string, fallback bool) {
|
|
backendGroupFallbackBackend.WithLabelValues(bg.Name, name, strconv.FormatBool(fallback)).Set(boolToFloat64(fallback))
|
|
}
|
|
|
|
func RecordBackendGroupMulticallRequest(bg *BackendGroup, backendName string) {
|
|
backendGroupMulticallCounter.WithLabelValues(bg.Name, backendName).Inc()
|
|
}
|
|
|
|
func RecordBackendGroupMulticallCompletion(bg *BackendGroup, backendName string, error string) {
|
|
backendGroupMulticallCompletionCounter.WithLabelValues(bg.Name, backendName, error).Inc()
|
|
}
|
|
|
|
func boolToFloat64(b bool) float64 {
|
|
if b {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|