Tokio metrics collector for Prometheus

Provides utilities for collecting Prometheus-compatible metrics from Tokio runtime and tasks.

toml [dependencies] tokio-metrics-collector = { version = "0.1.0" }

Documentation:

API reference (docs.rs)

QuickStart

```Rust use prometheus::Encoder;

[tokio::main]

async fn main() { // register global runtime collector prometheus::defaultregistry() .register(Box::new( tokiometricscollector::defaultruntime_collector(), )) .unwrap();

// register global task collector
let task_collector = tokio_metrics_collector::default_task_collector();
prometheus::default_registry()
    .register(Box::new(task_collector))
    .unwrap();

// construct a TaskMonitor
let monitor = tokio_metrics_collector::TaskMonitor::new();
// add this monitor to task collector with label 'simple_task'
task_collector.add("simple_task", monitor.clone());

// spawn a background task and instrument
tokio::spawn(monitor.instrument(async {
    loop {
        // do something
        tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
    }
}));

// print metrics every tick
for _ in 0..5 {
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;

    let encoder = prometheus::TextEncoder::new();
    let mut buffer = Vec::new();
    encoder
        .encode(&prometheus::default_registry().gather(), &mut buffer)
        .unwrap();
    let data = String::from_utf8(buffer.clone()).unwrap();

    println!("{}", data);
}

} ```

And a http server example, you can find in examples/server.rs.

Runtime Metrics

This unstable functionality requires tokio_unstable, and the rt crate feature. To enable tokio_unstable, the --cfg tokio_unstable must be passed to rustc when compiling. You can do this by setting the RUSTFLAGS environment variable before compiling your application; e.g.:

sh RUSTFLAGS="--cfg tokio_unstable" cargo build

Or, by creating the file .cargo/config.toml in the root directory of your crate. If you're using a workspace, put this file in the root directory of your workspace instead.

toml [build] rustflags = ["--cfg", "tokio_unstable"] rustdocflags = ["--cfg", "tokio_unstable"]

[workers_count]
The number of worker threads used by the runtime.
[total_park_count]
The number of times worker threads parked.
[total_noop_count]
The number of times worker threads unparked but performed no work before parking again.
[total_steal_count]
The number of tasks worker threads stole from another worker thread.
[total_steal_operations]
The number of times worker threads stole tasks from another worker thread.
[num_remote_schedules]
The number of tasks scheduled from outside of the runtime.
[total_local_schedule_count]
The number of tasks scheduled from worker threads.
[total_overflow_count]
The number of times worker threads saturated their local queues.
[total_polls_count]
The number of tasks that have been polled across all worker threads.
[total_busy_duration]
The amount of time worker threads were busy.
[injection_queue_depth]
The number of tasks currently scheduled in the runtime's injection queue.
[total_local_queue_depth]
The total number of tasks currently scheduled in workers' local queues.
[elapsed]
Total amount of time elapsed since observing runtime metrics.
[budget_forced_yield_count]
The number of times that a task was forced to yield because it exhausted its budget.
[io_driver_ready_count]
The number of ready events received from the I/O driver.

Task Metrics

[instrumented_count]
The number of tasks instrumented.
[dropped_count]
The number of tasks dropped.
[first_poll_count]
The number of tasks polled for the first time.
[total_first_poll_delay]
The total duration elapsed between the instant tasks are instrumented, and the instant they are first polled.
[total_idled_count]
The total number of times that tasks idled, waiting to be awoken.
[total_idle_duration]
The total duration that tasks idled.
[total_scheduled_count]
The total number of times that tasks were awoken (and then, presumably, scheduled for execution).
[total_scheduled_duration]
The total duration that tasks spent waiting to be polled after awakening.
[total_poll_count]
The total number of times that tasks were polled.
[total_poll_duration]
The total duration elapsed during polls.
[total_fast_poll_count]
The total number of times that polling tasks completed swiftly.
[total_fast_poll_duration]
The total duration of fast polls.
[total_slow_poll_count]
The total number of times that polling tasks completed slowly.
[total_slow_poll_duration]
The total duration of slow polls.
[total_short_delay_count]
The total count of short scheduling delays.
[total_short_delay_duration]
The total duration of short scheduling delays.
[total_long_delay_count]
The total count of long scheduling delays.
[total_long_delay_duration]
The total duration of long scheduling delays.

License

tokio-metrics-collector is distributed under the terms of both the MIT license and the Apache License (Version 2.0).

See LICENSE-APACHE and LICENSE-MIT, and COPYRIGHT for details.