Metrics reference

How it works

Initialization order. Every metric family is defined at package init and registered later, by a single telemetry.Configure call from erpc.Init. Definitions go through the Define* factories in telemetry/manager.go — DefineCounter, DefineGauge, DefineLabeledCounter, DefineLabeledHistogram — which record the family (with its kind) in the manager's index and return a usable, unregistered collector. Call sites hold that pointer for the process lifetime and never check whether it is registered.

Configure then, in order: compiles metrics.customizations and the deprecated label knobs into a single MetricPolicy (returning an error and registering nothing if an entry is malformed), resolves histogramBuckets, publishes the policy, and walks the definition index. For each family it skips the ones the policy drops, rebuilds the rest under the now-published policy — its label projection and, for a histogram, its per-family buckets — registers them with prometheus.DefaultRegisterer, and finally calls ResetHandleCache to invalidate handles pointing at the pre-rebuild Vecs. [telemetry/manager.go:L196-286]

The define/register split is forced by Prometheus: a registry freezes a family's label-set hash the first time it is registered and keeps it for the registry's lifetime (dimHashesByName survives Unregister). Anything that changes a label set — a labels rule, the deprecated histogramDropLabels/counterDropLabels — therefore has to be applied before the first registration. Dropping a family needs the same window for a different reason: the only way to keep a family off /metrics entirely is to never register it.

The policy engine. telemetry/policy.go owns every exposure, label and bucket decision, so there is exactly one precedence implementation. It compiles each customization into a rule carrying a compiled subject pattern (exact, prefix*, or *), an optional exposure action, its label rules and its buckets; the deprecated knobs desugar onto the same rule type with a kind mask (counterDropLabels becomes a counters-only * rule). Rules are sorted by specificity — exact beats prefix, longer prefix beats shorter, ties break to the later entry, and a desugared legacy knob sits below an equally specific customization so migrating a field takes effect. Lookups (Exposed, labelIndices, BucketsFor) walk the sorted rules and take the most specific match.

SetHistogramBuckets. A narrower entry point that resolves the bucket string and registers the histogram families only. Two callers use it: config validation, which wants the parse error and nothing else, and test setup, which needs histograms scrapeable while leaving counter label sets still open. Production goes through Configure.

Label projection (LabeledCounter, LabeledHistogram). Each wrapper stores the full canonical label schema alongside the projected subset the policy keeps for that family. Call sites always pass the full schema in schema order; the wrapper silently projects before forwarding to the underlying prometheus.CounterVec/HistogramVec. A length mismatch panics immediately. ActiveLabelValues returns the projected subset so handle-caches key on the effective (post-projection) labels, preventing duplicate series. Gauges are never projected — collapsing gauge series would report whichever writer wrote last rather than a coarser number. [telemetry/labeled_histogram.go:L117-130]

Handle caching. CounterHandle, GaugeHandle, and ObserverHandle in telemetry/handles.go cache children in sync.Maps keyed by {Vec pointer, '\x1f'-joined label values}. This avoids per-observation map lookup and mutex contention inside the Prometheus library. [telemetry/handles.go:L59-105]

Idle-series eviction. The health tracker's rotateMetricsLoop fires a sweep every 10 rotation ticks (default 30 s/tick = every 5 minutes). The sweep deletes upsMetrics and ntwMetrics entries not accessed in the last 30 minutes (DefaultIdleEvictionAfter), then calls DeleteLabelValues on erpc_upstream_request_duration_seconds and erpc_rate_limits_total. Cordoned entries and wildcard ("*") rollups are never evicted. All other high-cardinality series are NOT covered — cardinality is bounded only by distinct label tuples seen over the process lifetime. [health/tracker.go:L557-667]

Metrics HTTP server. erpc.Init starts a minimal http.Server bound to :%d (port only, all interfaces) serving the Prometheus handler at the root path. This means every URL path on the metrics port returns identical Prometheus text output — GET /, GET /metrics, GET /health all work. No TLS, no auth, no gzip. Shutdown is graceful with a 5-second budget. The gatherer is wrapped by telemetry.Gatherer, which applies the policy's drop rules to families the manager does not register itself (the stock go_*/process_*/promhttp_* collectors); with no customizations configured it hands the default gatherer straight through. [erpc/init.go:L184-215]

ERPC_NOMETRICS=1 env var. When set before process start, initflags.go:init() replaces prometheus.DefaultRegisterer and DefaultGatherer with a fresh empty registry. All subsequent registrations succeed but produce no-ops. The default go_*/process_* collectors are also dropped. [cmd/erpc/initflags.go:L22-28]

errorLabelMode global. common.ErrorSummary produces the error label value on every error-labeled metric. The in-code default before erpc.Init runs is verbose; erpc.Init flips it to compact (the config default). In compact mode it emits short stable codes: a plain StandardError → its Base().Code string (e.g. "ErrEndpointCapacityExceeded"); for ErrFailsafeRetryExceeded, ErrUpstreamRequest, or ErrUpstreamRequestSkipped it appends the cause code (e.g. "ErrUpstreamRequest/ErrEndpointTransportFailure"); for an ErrJsonRpcExceptionInternal cause it further appends the numeric code (e.g. "ErrUpstreamRequest/ErrJsonRpcExceptionInternal/-32000"). In verbose mode it passes the full message chain through cleanUpMessage (strips newlines and long hex strings), potentially including block numbers or IP addresses — each unique value creates a new Prometheus series. [common/errors.go:L17-114]

networkAlias resolver. At startup, erpc.Init installs a NetworkAliasResolver callback mapping raw EVM chain IDs to human-readable aliases so components using numeric chain IDs (e.g. gRPC cache connector) emit matching network label values. [erpc/init.go:L95-110]

Config schema

All fields are under metrics. in the root YAML config. Source: common/config.go:L2899-3016 (struct), common/defaults.go:L908-931 (defaults), common/validation.go:L139-171 (validation).

Precedence. Overlapping subjects resolve by specificity, not by list order: an exact family name beats a prefix, a longer prefix beats a shorter one, and two equally specific subjects break to the one written later. So drop consensus_* plus keep consensus_duration_seconds means the same thing whichever order it appears in, and appending a carve-out never requires reordering the list. The deprecated label knobs are desugared into the same rules but sit below an equally specific customizations entry, so migrating a field off them takes effect immediately.

Hardcoded server constants (not configurable):

• Bind address: ":%d" — all interfaces, port only (erpc/init.go:L189)
• Handler: the Prometheus handler registered as root /, over a gatherer wrapped by telemetry.Gatherer — every path returns full metrics output
• Protocol: plain HTTP only (no TLS, no auth, no gzip)
• ReadHeaderTimeout: 10 seconds
• Graceful shutdown budget: 5 seconds

Histograms affected by metrics.histogramBuckets: erpc_upstream_request_duration_seconds, erpc_network_request_duration_seconds, erpc_consensus_duration_seconds, erpc_cache_set_success_duration_seconds, erpc_cache_set_error_duration_seconds, erpc_cache_get_success_hit_duration_seconds, erpc_cache_get_success_miss_duration_seconds, erpc_cache_get_error_duration_seconds.

Histograms NOT affected by metrics.histogramBuckets: all remaining histograms declare dedicated inline bucket arrays, and the global list deliberately leaves those alone. They are still reachable via a customizations entry with buckets, which overrides the compiled-in array.

Worked examples

1. Drop user globally but keep it on one histogram for user-level latency analysis. Useful when you need per-user latency breakdowns on network_request_duration_seconds but want to limit cardinality everywhere else:

metrics:
  customizations:
    # Fleet-wide: no per-user, no per-agent dimensions.
    - subject: "*"
      labels:
        - subject: user
          action: drop
        - subject: agent_name
          action: drop
    # …except on this one histogram, which a latency dashboard reads per user.
    - subject: network_request_duration_seconds
      labels:
        - subject: user
          action: keep

2. Tighter histogram buckets for a low-latency deployment (sub-100ms upstreams). The default [0.05, 0.5, 5, 30] buckets produce poor p95/p99 resolution when upstreams respond in under 50ms. Replacing them gives useful percentile data at real latencies:

metrics:
  histogramBuckets: "0.005,0.01,0.025,0.05,0.1,0.25,0.5,1,3"

3. Disabling metrics during integration tests. erpc.Init defaults metrics.enabled to nil (disabled) under go test, but if you call Init with a partial config that doesn't go through SetDefaults, the server may try to start. Explicit override:

metrics:
  enabled: false

4. Keeping only the families a dashboard actually reads. The strongest cardinality lever available: a dropped family is never registered, so it costs no series, no collection time, and no scrape bytes. An allowlist is written explicitly — drop everything, then keep what you want — so nothing depends on which other keys are present. subject: "*" also covers the stock go_*/process_* collectors, so name them if you want to keep them:

metrics:
  customizations:
    - subject: "*"
      action: drop
    - subject: upstream_request_total
      action: keep
    - subject: upstream_request_errors_total
      action: keep
    - subject: network_request_duration_seconds
      action: keep
    - subject: "go_*"
      action: keep
    - subject: "process_*"
      action: keep

5. Keeping a subsystem but dropping its noisiest family. The exact subject is more specific than the prefix, so the carve-out does not require enumerating everything else — and the order of the two entries does not matter:

metrics:
  customizations:
    - subject: "consensus_*"
      action: keep
    - subject: consensus_responses_collected
      action: drop

6. Per-metric histogram buckets. metrics.histogramBuckets is one global list, which is the wrong resolution when two histograms measure different things. buckets on a customization overrides it — and the metric's own compiled-in buckets — for just the families the subject matches:

metrics:
  histogramBuckets: "0.05,0.5,5,30"
  customizations:
    # Sub-100ms upstreams need resolution the global list does not have.
    - subject: upstream_request_duration_seconds
      buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 1]
    # This one counts blocks, not seconds.
    - subject: network_evm_get_logs_range_requested
      buckets: [10, 100, 1000, 10000, 100000]

7. Switching to verbose error labels for a debugging session. When you need to trace a specific block-number error pattern in Grafana and short codes aren't enough — but remember to revert after, as each unique block number creates a new Prometheus series:

metrics:
  errorLabelMode: verbose

Behavioral invariants

• No metric family is registered at package init. Every family — counters, gauges, histograms — becomes scrapeable only once telemetry.Configure runs from erpc.Init. A process that never calls Init (or calls it with a config whose metrics section is absent) exposes the histogram families only. [telemetry/manager.go]
• Exposure is a startup decision. A family dropped by a customization is never registered, so it cannot be turned back on without a restart — and a family that was registered cannot be removed by a later Configure, because Prometheus keeps the frozen label-set hash for the registry's lifetime.
• Metrics still count when metrics.enabled is false: enabled only controls whether the HTTP server starts. A drop customization is what actually prevents a family from existing.
• A customization with no action never affects exposure. It customizes labels or buckets only, and it does not turn on the scrape-path filter that hides stock collectors.
• A repeat Configure on the same registry leaves already-registered families untouched — their label sets are frozen, and accumulated values are preserved. Changing customizations or histogramBuckets requires a restart.
• ERPC_NOMETRICS=1 swaps prometheus.DefaultRegisterer/DefaultGatherer for a fresh empty registry before Configure runs — all subsequent registrations succeed but produce no-ops; the stock go_*/process_* collectors are also dropped. [cmd/erpc/initflags.go:L22-28]
• Idle sweep runs every 5 minutes (default); series not accessed in 30 minutes are evicted from upstream_request_duration_seconds and rate_limits_total via DeleteLabelValues. [health/tracker.go:L557-667]
• The error label value is produced by common.ErrorSummary. Compact mode yields a bounded set of code-path identifiers; verbose mode can produce one series per unique block number or IP. [common/errors.go:L46-66]
• erpc_rate_limiter_budget_decision_total is registered but has zero production call sites — always zero. [telemetry/metrics.go:L515-519]
• erpc_network_hedge_delay_seconds is registered but never observed in production — always empty. [telemetry/metrics.go:L813]

Best practices

• Use errorLabelMode: compact (the default) in production. Verbose mode can create one Prometheus series per unique block number or IP address in error messages — this is an unbounded cardinality hazard.
• Drop user and agent_name with a subject: "*" customization when serving untrusted callers or managing many API keys. These labels are the leading cardinality source across the projected families. Re-add them with an exact subject on the one or two metrics a dashboard or billing pipeline actually reads.
• Do not rely on hostV4/hostV6 to restrict scrape access — the server binds all interfaces regardless of those fields. Use firewall rules or network policy to limit who can reach port 4001.
• Alert on erpc_network_failed_request_total{severity="critical"} and page on severity="warning". Severity is already classified by common.ClassifySeverity — no need to build your own error-code regexes.
• Use erpc_rate_limits_total for rate-limit alerting. The bundled alert rule referencing erpc_upstream_request_self_rate_limited_total uses a stale metric name that no longer exists.
• Monitor erpc_upstream_cordoned as an early-warning signal for upstream health. A non-zero value means eRPC has autonomously excluded that upstream; combine with erpc_upstream_cordon_event_total to track how often it happens.
• For erpc_network_evm_block_range_requested_total, be aware the bucket label is unbounded. Consider a Prometheus metric_relabel_configs drop rule for the bucket label if long-running chains accumulate too many series.

Edge cases & gotchas

1. hostV4/hostV6 are defined but unused. The bind address is always ":%d" (all interfaces). Firewall rules are the only way to restrict access to the metrics port. (erpc/init.go:L189)
2. metrics.enabled is nil (disabled) under go test. Integration tests that call erpc.Init will not spin up a metrics server unless Enabled: true is set explicitly. (common/defaults.go:L909-911)
3. Changing errorLabelMode does not retroactively relabel existing series. Counter Vec children are created lazily on first WithLabelValues. Any series created before erpc.Init sets the mode carry verbose labels; subsequent series carry compact labels. Both sets coexist in Prometheus until the verbose series naturally expire.
4. Label-set, bucket and exposure changes need a restart. Prometheus keeps a family's label-set hash for the registry's lifetime, so a second Configure leaves already-registered families exactly as they are — a changed customizations list or histogramBuckets is silently not applied to them. (telemetry/manager.go)
5. A subject that matches nothing is only a warning. A typo'd family name is not a validation error — Init logs the unmatched subjects, quoting the text you wrote, and starts anyway. Check the startup log for subjects match no known metric family after editing the list. Subjects naming a stock collector are excluded from the check, since those are registered outside the manager and are never in KnownFamilies.
6. A rule aimed at a family that cannot honor it is also only a warning. buckets on a counter, or labels on a plain counter or gauge whose label set is fixed in code, is silently ignored; Init warns only when an exact subject names such a family, so a sweeping subject: "*" does not produce one warning per family. Look for rules do not apply to the family they name.
7. Third-party collectors outside go_*/process_*/promhttp_* cannot be addressed. Any other name is normalized by prepending erpc_, so a collector registered by a dependency under some other prefix is unreachable from customizations — subject: "*", action: drop still removes it (via the scrape filter), but no keep can name it back. (telemetry/policy.go)
8. Idle sweep evicts only upstream_request_duration_seconds and rate_limits_total. All other high-cardinality histograms and counters (network_request_duration_seconds, upstream_request_total, etc.) are never DeleteLabelValues'd — they grow monotonically. For method-flood scenarios drop user and agent_name with a subject: "*" customization.
9. erpc_cors_requests_total project label receives r.URL.Path, not the project ID. Series will have values like /myproject/evm/1. Dashboard queries on CORS metrics must match the path-style value, not a bare project ID. (erpc/http_server.go:L1020)
10. erpc_ristretto_cache_current_cost requires memory.emitMetrics: true. Without this flag the gauge is registered and appears in /metrics but always returns 0. It is the only metric in the system requiring an explicit opt-in to be meaningful. (data/memory.go:L71)
11. erpc_upstream_cordoned category label is the cordon scope (method string or "*"), not a request-category label. Do not join this category with category from request-accounting metrics. (health/tracker.go:L458-465)
12. erpc_upstream_cordoned vendor label is "n/a" when no vendor is configured. Dashboard JOINs between cordon metrics and upstream request metrics must handle the "n/a" value for unvendored upstreams. (upstream/upstream.go:L275-286)
13. erpc_auth_failed_total always has strategy="database". Only the database auth strategy emits this counter. For other strategies, monitor failures via erpc_network_failed_request_total{error=~"ErrAuthUnauthorized.*"}. (auth/strategy_database.go:L467-472)
14. erpc_upstream_attempt_outcome_total is_hedge/is_retry are literal "true"/"false" strings. Use {is_hedge="true"} in PromQL, not {is_hedge="1"}. (upstream/upstream.go:L80-85)
15. erpc_network_evm_block_range_requested_total bucket label is unbounded. When tip is known, ComputeBlockHeatmapBucket produces human-readable relative labels ("TIP", "L100k", "100k-200k", etc.). This counter is not covered by the idle sweep — cardinality grows permanently. (erpc/block_heatmap.go:L87-175)
16. erpc_selection_* metrics carry a method label. Untrusted callers injecting hundreds of distinct method names create unbounded selection-gauge series. Consider a Prometheus relabeling drop rule for the method label in untrusted deployments.
17. erpc_upstream_block_head_large_rollback is silent for rollbacks ≤ 1024 blocks, and sticky above them. DefaultToleratedBlockHeadRollback = 1024 is the threshold. The gauge is Set to the rollback size and is never reset, so > 0 means "this process saw a rollback at some point", not "a rollback is happening now", and rate()/increase() are meaningless on it. Alert on changes(...[window]), split by the finality label. (architecture/evm/evm_state_poller.go:L27)
18. Cordoned upstreams are never swept. A cordoned tracker entry persists in memory — and the erpc_upstream_cordoned{...} = 1 gauge persists in /metrics — until the upstream is uncordoned and subsequently goes idle for idleEvictionAfter. (health/tracker.go:L603-608)
19. erpc_network_dynamic_block_time_milliseconds is bounded 10ms–120s. Fast chains (block time below 10ms) or stuck chains (no blocks for over 2 minutes) report the floor or ceiling value, not the true EMA. (health/tracker.go:L1456)
20. Two bundled alert rules reference stale metric names. erpc_upstream_request_self_rate_limited_total and erpc_network_request_self_rate_limited_total no longer exist — use erpc_rate_limits_total as the replacement. (monitoring/prometheus/alert.rules:L1)
21. The bundled Prometheus scrape target includes REPLACE_SERVICE_ENDPOINT_HERE and REPLACE_SERVICE_PORT_HERE placeholders. These are Railway deployment stubs that cause a parse error in strict Prometheus configs. Remove or replace both before using monitoring/prometheus/prometheus.yml in production.
22. ParseHistogramBuckets silently sorts the input. If metrics.histogramBuckets is provided out of order (e.g. "5,0.5,0.05,30") the values are sorted automatically and no warning is emitted. The resulting bucket set is valid, but operators relying on a specific insertion order will not get what they typed. [telemetry/metrics.go:L1133-1151]
23. erpc_upstream_response_size_bytes is intentionally tight-cardinality. Its label set is project, network, category, finality — no user or upstream — because per-user response-size breakdown is not operationally actionable. If you need per-user latency analysis, retain user on erpc_upstream_request_duration_seconds with an exact-subject labels: [{subject: user, action: keep}] customization instead of not dropping it globally. [telemetry/metrics.go:L1125-1130]
24. erpc_upstream_request_duration_seconds has two high-cardinality labels: user and composite. The composite label carries the composite-request type (e.g. "logs-split-on-error", "query-logs-shim") and, combined with user, can produce many series in high-traffic deployments. Both are candidates for a labels: [{subject: ..., action: drop}] customization; the idle sweep (DefaultIdleEvictionAfter = 30 min) provides a safety valve. [health/tracker.go:L333-358]
25. ErrEndpointServerSideException HTTP status code is not exposed as a Prometheus label. When an upstream returns an HTTP 5xx that does not match a known pattern, eRPC wraps it in ErrEndpointServerSideException and echoes the upstream's status code back to the caller via ErrorStatusCode(). The raw numeric code surfaces in erpc_upstream_request_errors_total{error="ErrEndpointServerSideException"} in compact mode (no code number) or in the full message in verbose mode, but no label carries it. For debugging, use OTel traces: SetTraceSpanError attaches attribute.String("error.code", stdErr.CodeChain()) and the serialised StandardError JSON to the span — though originalStatusCode is a private field and is not in the JSON output. The only way to retrieve the exact upstream HTTP status is from structured logs (logged at DEBUG level before wrapping). [common/errors.go:L1951-1979]

Full metrics catalog

All metric names carry the erpc_ prefix. Full definitions: telemetry/metrics.go:L11-1131.

Area 1: Upstream request accounting

Area 2: Network request accounting

Area 3: Block number and tip tracking

On SVM networks these carry slots, not block heights. The names were coined for EVM and are reused verbatim by the SVM state poller, so erpc_upstream_latest_block_number is the upstream's processed slot, erpc_upstream_finalized_block_number its finalized (rooted) slot, and the *_lag gauges count slots. That distinction is not cosmetic: a skipped Solana slot advances the slot counter but not the block height, so slot and height are different counters. The rollback threshold on SVM is DefaultToleratedSlotRollback = 1024 slots. erpc_upstream_stale_latest_block_total fires when a getSlot answer is corrected to the highest known slot for its commitment. The poller emits no *_polled_total, no erpc_network_dynamic_block_time_milliseconds, no served-tip gauges, and no metric at all for shred-insert (ingestion) lag — see SVM slot tracking & health.

Area 4: Cache connector freshness

Area 5: Cache operations (JSON-RPC cache)

Area 6: Rate limiting

Area 7: Upstream health (cordon, circuit-breaker, probing)

Area 8: Selection policy

Area 9: Consensus

Area 10: Hedging

Area 11: EVM method-specific

Area 12: gRPC BDS resilience

Area 13: CORS

Area 14: Shadow testing

Area 15: Auth

Area 16: Panics

Histogram bucket sets

Only DefaultHistogramBuckets are configurable at runtime. All other bucket sets require a recompile.

Observability

The metrics endpoint: http://<host>:<metrics.port>/ (any path) — the Prometheus handler is mounted at the root, so every HTTP path on port 4001 returns the full Prometheus text exposition. Plain HTTP only, no auth, no path routing. Reference scrape config at monitoring/prometheus/prometheus.yml (opens in a new tab) (scrape interval 10 s, default target host.docker.internal:4001).

Stock collectors (present unless ERPC_NOMETRICS=1): go_* — Go runtime stats; process_* — OS process stats; promhttp_metric_handler_* — handler self-scrape stats.

Bundled alerting rules (monitoring/prometheus/alert.rules):

Metrics server log lines (all emitted by erpc/init.go):

Both "failed to apply metrics configuration" lines are only reachable when erpc.Init is called as a library: the CLI rejects a malformed customization and a bad bucket list in MetricsConfig.Validate before Init runs. The wrapped error names the offending field either way.

Source code entry points

• telemetry/manager.go (opens in a new tab) — the definition index; the Define* factories; Configure; SetHistogramBuckets; KnownFamilies; Gatherer
• telemetry/policy.go (opens in a new tab) — NormalizeMetricName; Customization; MetricPolicy (subject/label precedence, per-family buckets, legacy desugaring)
• telemetry/gather_filter.go (opens in a new tab) — FilteredGatherer, which applies the policy's drop rules to collectors the manager does not own
• telemetry/metrics.go (opens in a new tab) — all 141 metric definitions; bucket constants; DefaultHistogramBuckets; ParseHistogramBuckets
• telemetry/labeled_histogram.go:L16-L134 (opens in a new tab) — LabeledHistogram with WithLabelValues, DeleteLabelValues, ActiveLabelValues, rebuildInPlace
• telemetry/handles.go:L59-L105 (opens in a new tab) — CounterHandle/GaugeHandle/ObserverHandle caches; ResetHandleCache
• telemetry/labeled_counter.go:L14-L122 (opens in a new tab) — LabeledCounter with WithLabelValues, DeleteLabelValues, ActiveLabelValues, rebuildInPlace
• erpc/init.go (opens in a new tab) — initialization sequence: MetricsConfig.TelemetryOptions → telemetry.Configure → unmatched/ignored-customization warnings → network alias resolver → metrics HTTP server lifecycle
• common/config.go (opens in a new tab) — MetricsConfig, MetricsCustomizationConfig and MetricLabelCustomizationConfig structs; TelemetryOptions
• common/defaults.go (opens in a new tab) — MetricsConfig.SetDefaults
• common/errors.go:L17-L114 (opens in a new tab) — errorLabelMode global; SetErrorLabelMode; ErrorSummary
• health/tracker.go:L481-L667 (opens in a new tab) — DefaultIdleEvictionAfter; rotateMetricsLoop; sweepIdle; sweepIdleObservers
• cmd/erpc/initflags.go:L22-L28 (opens in a new tab) — ERPC_NOMETRICS=1 registry replacement
• monitoring/catch-up-metrics.md (opens in a new tab) — operator guide for reading erpc_network_retry_attempt_total + erpc_network_data_unavailable_wait_seconds together; covers CatchUpWaitHistogramBuckets design rationale, finality-label split, Little's Law pressure interpretation, and tuning knobs

Related pages

• Rate limiters — the erpc_rate_limits_total counter tracks every budget decision.
• Failsafe: Hedge — erpc_network_hedged_request_total and erpc_network_hedge_winner_total are the hedge observability surface.
• Failsafe: Retry — erpc_network_retry_attempt_total with its reason label tracks retry behavior.
• Selection policies — the erpc_selection_* family tracks tick-by-tick upstream ranking.
• Cache — erpc_cache_get_* and erpc_cache_set_* families cover all cache connector activity.
• Auth — erpc_auth_failed_total for database-strategy failures.