Struct Metrics 

pub struct Metrics {
    _runtime: Option<Handle>,
    runtime_metrics: Option<RuntimeMetrics>,
    task_monitor: Option<TaskMonitor>,
    task_intervals: Mutex<Option<Box<dyn Iterator<Item = TaskMetrics> + Send>>>,
    pub requests_count: AtomicU64,
    pub requests_handle_finished: AtomicU64,
    pub requests_handle_active: AtomicU32,
    pub requests_panic: AtomicU32,
}

Owns process-wide runtime, task, and request measurements.

Task monitoring is available in builds with Tokio’s unstable metrics. Runtime monitoring additionally requires an embedding runtime handle, while request counters remain independent of either monitor.

Fields

_runtime: Option<Handle>

runtime_metrics: Option<RuntimeMetrics>

task_monitor: Option<TaskMonitor>

task_intervals: Mutex<Option<Box<dyn Iterator<Item = TaskMetrics> + Send>>>

requests_count: AtomicU64

Supplies identifiers for traced requests.

The tracing span consumes and increments the sequence when its fields are evaluated. It is not an unconditional request-traffic counter.

requests_handle_finished: AtomicU64

Counts request handlers that have finished in debug builds.

The counter is monotonic and remains separate from the gauge of handlers still active. Release builds leave it at zero.

requests_handle_active: AtomicU32

Tracks request handlers currently executing in debug builds.

The value is a gauge rather than a lifetime total. Release builds leave it at zero.

requests_panic: AtomicU32

Counts request handlers that terminated through panic handling.

The counter is scoped to request handling rather than all process panics. It is monotonic for the lifetime of the process.

Implementations

impl Metrics

pub fn new(runtime: Option<&Handle>) -> Arc<Self>

Creates shared metrics state for an optional runtime.

A runtime handle enables runtime snapshots. Builds exposing Tokio’s unstable metrics also install task monitoring independently of that handle.

pub async fn instrument<F, Output>(&self, f: F) -> Output

where F: Future<Output = Output>,

Awaits a future under task instrumentation when a monitor is available.

Instrumented futures contribute to task interval snapshots. Builds without a task monitor await the future directly with no wrapper.

pub fn task_interval(&self) -> Option<TaskMetrics>

Advances the task monitor and returns its next interval sample.

A server without task monitoring returns None. Samples describe only futures explicitly passed through Self::instrument.

Panics

Panics when the interval mutex is poisoned.

pub fn num_workers(&self) -> usize

Returns the number of workers in the monitored runtime.

A server constructed without a runtime handle reports zero. The value comes directly from Tokio’s runtime metrics snapshot.

pub fn task_metrics(&self) -> Option<&TaskMonitor>

Returns the optional task monitor.

The monitor exists only when task metrics were enabled at construction. It may be used to instrument futures or inspect cumulative task measurements.

pub fn runtime_metrics(&self) -> Option<&RuntimeMetrics>

Returns the optional Tokio runtime metrics handle.

The handle exists when server construction received an embedding runtime. Callers borrow it without advancing any interval monitor.