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, queue: &str, depth: usize)

Update the depth of a buffered stage’s queue (camel_queue_depth{queue}). The queue label is a closed set of component-declared identifiers (seda:<endpoint-name>, aggregator:<route>, resequencer:<route>).

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).

fn increment_retry_attempt(&self, scheme: &str, operation: &str)

Increment the per-attempt retry counter (camel_retry_attempts_total, labels scheme+operation). Called once per retry attempt, including the first. Default: no-op (backward-compatible).

fn increment_circuit_breaker_rejection(&self, route: &str)

Increment the circuit-breaker rejection counter (camel_circuit_breaker_rejections_total, label route). Open-breaker fast-fails count here, not as errors. Default: no-op (backward-compatible).

fn set_route_state(&self, route: &str, state: &str)

Publish a route lifecycle-state transition (camel_route_state, labels route+state). state is the projection’s state label — a closed set by construction (Registered, Starting, Started, Suspended, Stopping, Stopped, Failed). Implementations keep the route’s last-published state so a transition sets the new series to 1 and zeroes the previous one. Default: no-op (backward-compatible).

fn clear_route_state(&self, route: &str)

Drop a route’s state series (route removed/undeployed) so a scrape reflects only routes that exist.

fn record_build_info(&self, version: &str, git_sha: &str)

Publish build identification (camel_build_info{git_sha,version}, value 1). Called once when the context is built. Default: no-op (backward-compatible).

fn record_uptime(&self, seconds: f64)

Publish process uptime in seconds (camel_uptime_seconds), refreshed periodically by the runtime. Default: no-op (backward-compatible).

fn record_component_operation( &self, component: &str, operation: &str, outcome: &str, )

Increment the uniform component-operations counter (camel_component_operations_total, labels component+operation+ outcome). outcome is a closed set — “success” or “failure” only; callers derive it from a bool (see ComponentMetrics), never pass free text. Default: no-op (backward-compatible).

fn set_pinned_client_cache_size(&self, component: &str, entries: u64)

Publish the pinned client cache size for a component (camel_pinned_client_cache_size{component}, gauge, unit: entries). Emitted by the owning component after each lookup, reflecting the current (approximate) entry count. Default: no-op (backward-compatible).

fn increment_pinned_client_cache_hit(&self, component: &str)

Increment the pinned client cache hit counter for a component (camel_pinned_client_cache_hits_total{component}) — a pinned lookup served by the cache without a rebuild. Default: no-op (backward-compatible).

fn increment_pinned_client_cache_miss(&self, component: &str)

Increment the pinned client cache miss counter for a component (camel_pinned_client_cache_misses_total{component}) — a pinned lookup that required a client rebuild. Default: no-op (backward-compatible).

fn set_allocator_memory(&self, stat: AllocatorStat, bytes: u64)

Publish an allocator memory statistic (camel_allocator_memory_bytes{stat}, gauge, unit: bytes). stat is a closed AllocatorStat variant; the sampler refreshes the current value periodically. Default: no-op (backward-compatible).