Struct MetricsHandle 

pub struct MetricsHandle { /* private fields */ }

A late-bound MetricsCollector cell.

Contract:

• Late binding: a MetricsHandle can be handed to consumers before any real collector exists; it seeds itself with NoOpMetrics so calls before (and without) registration are safe no-ops.
• Composition, not replacement: each MetricsHandle::register composes the new collector over the currently stored one (see CompositeMetricsCollector); previously registered collectors keep observing.
• Same-Arc idempotence: registering the same collector Arc twice is a no-op (detected via Arc::ptr_eq against the membership list), so a call site that wires the same collector through two builder paths does not double-count.
• Delegation cost: each trait-method call costs one atomic load of the stored Arc (ArcSwap::load); the hot path never clones the Arc.

Implementations

impl MetricsHandle

pub fn new() -> Self

Creates a handle that delegates to NoOpMetrics until a collector is registered.

pub fn register(&self, collector: Arc<dyn MetricsCollector>)

Registers collector, composing it over whatever is currently stored.

If the exact same Arc was already registered, this is a no-op (see same-Arc idempotence in the type-level docs).

Trait Implementations

impl Default for MetricsHandle

fn default() -> Self

Returns the “default value” for a type.

impl MetricsCollector for MetricsHandle

fn record_exchange_duration(&self, route_id: &str, duration: Duration)

Record exchange processing time

fn increment_errors(&self, route_id: &str, error_type: &str)

Increment error counter

fn increment_exchanges(&self, route_id: &str)

Increment exchange counter

fn set_queue_depth(&self, route_id: &str, depth: usize)

Update queue depth

fn record_circuit_breaker_change(&self, route_id: &str, from: &str, to: &str)

Record circuit breaker state change

fn record_histogram(&self, name: &str, value: f64, labels: &[(&str, &str)])

Record a histogram observation (e.g., cost, latency distribution). Default: no-op (backward-compatible).

fn record_counter(&self, name: &str, value: f64, labels: &[(&str, &str)])

Record a monotonically-increasing counter (e.g. foo_total). Default: no-op (backward-compatible).