Struct RuntimeMetrics 

pub struct RuntimeMetrics { /* private fields */ }

Handle to the runtime’s metrics.

This handle is internally reference-counted and can be freely cloned. A RuntimeMetrics handle is obtained using the Runtime::metrics method.

Implementations

impl RuntimeMetrics

pub fn num_workers(&self) -> usize

Returns the number of worker threads used by the runtime.

The number of workers is set by configuring worker_threads on runtime::Builder. When using the current_thread runtime, the return value is always 1.

Examples

use tokio::runtime::Handle;

#[tokio::main]
async fn main() {
    let metrics = Handle::current().metrics();

    let n = metrics.num_workers();
    println!("Runtime is using {} workers", n);
}

pub fn num_alive_tasks(&self) -> usize

Returns the current number of alive tasks in the runtime.

This counter increases when a task is spawned and decreases when a task exits.

Examples

use tokio::runtime::Handle;

#[tokio::main]
async fn main() {
   let metrics = Handle::current().metrics();

    let n = metrics.num_alive_tasks();
    println!("Runtime has {} alive tasks", n);
}

pub fn global_queue_depth(&self) -> usize

Returns the number of tasks currently scheduled in the runtime’s global queue.

Tasks that are spawned or notified from a non-runtime thread are scheduled using the runtime’s global queue. This metric returns the current number of tasks pending in the global queue. As such, the returned value may increase or decrease as new tasks are scheduled and processed.

Examples

use tokio::runtime::Handle;

#[tokio::main]
async fn main() {
    let metrics = Handle::current().metrics();

    let n = metrics.global_queue_depth();
    println!("{} tasks currently pending in the runtime's global queue", n);
}

pub fn worker_total_busy_duration(&self, worker: usize) -> Duration

Returns the amount of time the given worker thread has been busy.

The worker busy duration starts at zero when the runtime is created and increases whenever the worker is spending time processing work. Using this value can indicate the load of the given worker. If a lot of time is spent busy, then the worker is under load and will check for inbound events less often.

The timer is monotonically increasing. It is never decremented or reset to zero.

Arguments

worker is the index of the worker being queried. The given value must be between 0 and num_workers(). The index uniquely identifies a single worker and will continue to identify the worker throughout the lifetime of the runtime instance.

Panics

The method panics when worker represents an invalid worker, i.e. is greater than or equal to num_workers().

Examples

use tokio::runtime::Handle;

#[tokio::main]
async fn main() {
    let metrics = Handle::current().metrics();

    let n = metrics.worker_total_busy_duration(0);
    println!("worker 0 was busy for a total of {:?}", n);
}

pub fn worker_park_count(&self, worker: usize) -> u64

Returns the total number of times the given worker thread has parked.

The worker park count starts at zero when the runtime is created and increases by one each time the worker parks the thread waiting for new inbound events to process. This usually means the worker has processed all pending work and is currently idle.

The counter is monotonically increasing. It is never decremented or reset to zero.

Arguments

worker is the index of the worker being queried. The given value must be between 0 and num_workers(). The index uniquely identifies a single worker and will continue to identify the worker throughout the lifetime of the runtime instance.

Panics

The method panics when worker represents an invalid worker, i.e. is greater than or equal to num_workers().

Examples

use tokio::runtime::Handle;

#[tokio::main]
async fn main() {
    let metrics = Handle::current().metrics();

    let n = metrics.worker_park_count(0);
    println!("worker 0 parked {} times", n);
}

pub fn worker_park_unpark_count(&self, worker: usize) -> u64

Returns the total number of times the given worker thread has parked and unparked.

The worker park/unpark count starts at zero when the runtime is created and increases by one each time the worker parks the thread waiting for new inbound events to process. This usually means the worker has processed all pending work and is currently idle. When new work becomes available, the worker is unparked and the park/unpark count is again increased by one.

An odd count means that the worker is currently parked. An even count means that the worker is currently active.

The counter is monotonically increasing. It is never decremented or reset to zero.

Arguments

worker is the index of the worker being queried. The given value must be between 0 and num_workers(). The index uniquely identifies a single worker and will continue to identify the worker throughout the lifetime of the runtime instance.

Panics

The method panics when worker represents an invalid worker, i.e. is greater than or equal to num_workers().

Examples

use tokio::runtime::Handle;

#[tokio::main]
async fn main() {
    let metrics = Handle::current().metrics();
    let n = metrics.worker_park_unpark_count(0);

    println!("worker 0 parked and unparked {} times", n);

    if n % 2 == 0 {
        println!("worker 0 is active");
    } else {
        println!("worker 0 is parked");
    }
}

Trait Implementations

impl Clone for RuntimeMetrics

fn clone(&self) -> RuntimeMetrics

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RuntimeMetrics

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.