#metrics #tokio #prometheus

tokio-metrics-collector

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

5 releases

0.2.1 Nov 28, 2023
0.2.0 May 8, 2023
0.1.0 Apr 20, 2023
0.1.0-beta.0 Apr 19, 2023

#161 in Development tools

Download history 325/week @ 2023-10-26 448/week @ 2023-11-02 164/week @ 2023-11-09 316/week @ 2023-11-16 275/week @ 2023-11-23 339/week @ 2023-11-30 440/week @ 2023-12-07 541/week @ 2023-12-14 646/week @ 2023-12-21 685/week @ 2023-12-28 907/week @ 2024-01-04 839/week @ 2024-01-11 931/week @ 2024-01-18 851/week @ 2024-01-25 758/week @ 2024-02-01 557/week @ 2024-02-08

3,235 downloads per month
Used in static-web-server

MIT/Apache

52KB
909 lines

Tokio metrics collector for Prometheus

tokio-metrics-collector on GitHub Action codecov tokio-metrics-collector on crates.io tokio-metrics-collector on docs.rs

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

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

Documentation:

QuickStart

use prometheus::Encoder;

#[tokio::main]
async fn main() {
    // register global runtime collector
    prometheus::default_registry()
        .register(Box::new(
            tokio_metrics_collector::default_runtime_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'
    // NOTE: duplicate labels in multiple monitors cause incorrect data aggregation.
    // It is recommended to use unique labels for each monitor and
    // instrument multiple tasks by the `instrument` function.
    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.:

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.

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

Task Metrics

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.

Dependencies

~5–13MB
~131K SLoC