impl RuntimeMetrics

fn num_workers(self: &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);
}

fn num_alive_tasks(self: &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);
}

fn global_queue_depth(self: &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);
}

fn worker_total_busy_duration(self: &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);
}

fn worker_park_count(self: &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);
}

fn worker_park_unpark_count(self: &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");
    }
}

impl Clone for RuntimeMetrics

fn clone(self: &Self) -> RuntimeMetrics

impl Debug for RuntimeMetrics

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

impl Freeze for RuntimeMetrics

impl RefUnwindSafe for RuntimeMetrics

impl Send for RuntimeMetrics

impl Sync for RuntimeMetrics

impl Unpin for RuntimeMetrics

impl UnsafeUnpin for RuntimeMetrics

impl UnwindSafe for RuntimeMetrics

impl<T> Any for RuntimeMetrics

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for RuntimeMetrics

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for RuntimeMetrics

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for RuntimeMetrics

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for RuntimeMetrics

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for RuntimeMetrics

fn to_owned(self: &Self) -> T

fn clone_into(self: &Self, target: &mut T)

impl<T, U> Into for RuntimeMetrics

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for RuntimeMetrics

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for RuntimeMetrics

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>