TaskMetrics 与派生指标

struct RawMetrics {
    slow_poll_threshold: Duration,
    long_delay_threshold: Duration,
    instrumented_count: AtomicU64,
    first_poll_count: AtomicU64,
    total_idled_count: AtomicU64,
    total_scheduled_count: AtomicU64,
    total_fast_poll_count: AtomicU64,
    total_slow_poll_count: AtomicU64,
    total_long_delay_count: AtomicU64,
    total_short_delay_count: AtomicU64,
    dropped_count: AtomicU64,
    total_first_poll_delay_ns: AtomicU64,
    total_idle_duration_ns: AtomicU64,
    local_max_idle_duration_ns: AtomicU64,
    global_max_idle_duration_ns: AtomicU64,
    total_scheduled_duration_ns: AtomicU64,
    total_fast_poll_duration_ns: AtomicU64,
    total_slow_poll_duration: AtomicU64,
    total_short_delay_duration_ns: AtomicU64,
    total_long_delay_duration_ns: AtomicU64,
}

    fn metrics(&self) -> TaskMetrics {
        let total_fast_poll_count = self.total_fast_poll_count.load(SeqCst);
        let total_slow_poll_count = self.total_slow_poll_count.load(SeqCst);

        let total_fast_poll_duration =
            Duration::from_nanos(self.total_fast_poll_duration_ns.load(SeqCst));
        let total_slow_poll_duration =
            Duration::from_nanos(self.total_slow_poll_duration.load(SeqCst));

        let total_poll_count = total_fast_poll_count.saturating_add(total_slow_poll_count);
        let total_poll_duration = total_fast_poll_duration.saturating_add(total_slow_poll_duration);

        TaskMetrics {
            instrumented_count: self.instrumented_count.load(SeqCst),
            // ...
            max_idle_duration: Duration::from_nanos(self.global_max_idle_duration_ns.load(SeqCst)),
            // ...
        }
    }

use std::time::{Duration, Instant};
use tokio_metrics::{TaskMetrics, TaskMonitor};

fn spin(d: Duration) {
  let t = Instant::now();
  while t.elapsed() < d {}
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  // 1. 一次 poll 都没有时的派生指标
  let empty = TaskMetrics::default();
  println!(
    "empty: mean_poll={:?} mean_sched={:?} slow_poll_ratio={} long_delay_ratio={}",
    empty.mean_poll_duration(), empty.mean_scheduled_duration(),
    empty.slow_poll_ratio(), empty.long_delay_ratio()
  );

  // 2. 在途数 = instrumented - dropped
  let m = TaskMonitor::new();
  let never_polled = m.instrument(async {}); // 包了，还没 spawn
  let pending = tokio::spawn(m.instrument(std::future::pending::<()>())); // 永远不完成
  tokio::spawn(m.instrument(async { spin(Duration::from_micros(80)) })).await.unwrap();
  tokio::task::yield_now().await; // 让 pending 那个跑一次
  let c = m.cumulative();
  println!(
    "in flight: instrumented={} dropped={} -> {}; first_polls={}",
    c.instrumented_count, c.dropped_count, c.instrumented_count - c.dropped_count, c.first_poll_count
  );
  println!(
    "polls: total={} fast={} slow={} slow_poll_ratio={:.2} thresholds={:?}/{:?}",
    c.total_poll_count, c.total_fast_poll_count, c.total_slow_poll_count, c.slow_poll_ratio(),
    m.slow_poll_threshold(), m.long_delay_threshold()
  );
  drop(never_polled);
  pending.abort();
  let _ = pending.await;
  let c = m.cumulative();
  println!("after drop/abort: instrumented={} dropped={}", c.instrumented_count, c.dropped_count);
}

empty: mean_poll=0ns mean_sched=0ns slow_poll_ratio=NaN long_delay_ratio=NaN
in flight: instrumented=3 dropped=1 -> 2; first_polls=2
polls: total=2 fast=1 slow=1 slow_poll_ratio=0.50 thresholds=50µs/50µs
after drop/abort: instrumented=3 dropped=3

macro_rules! derived_metrics {
    (
        [$metrics_name:ty] {
            stable {
                $(
                    $(#[$($attributes:tt)*])*
                    $vis:vis fn $name:ident($($args:tt)*) -> $ty:ty $body:block
                )*
            }
            unstable {
                // ... 同上，换一组变量名
            }
        }
    ) => {
        impl $metrics_name {
            $(
                $(#[$($attributes)*])*
                $vis fn $name($($args)*) -> $ty $body
            )*
            $(
                $(#[$($unstable_attributes)*])*
                #[cfg(tokio_unstable)]
                $unstable_vis fn $unstable_name($($unstable_args)*) -> $unstable_ty $unstable_body
            )*

            #[cfg(all(test, feature = "metrics-rs-integration"))]
            const DERIVED_METRICS: &[&str] = &[$(stringify!($name),)*];
            // ...
        }
    };
}

fn mean(d: Duration, count: u64) -> Duration {
    if let Some(quotient) = to_nanos(d).checked_div(count) {
        Duration::from_nanos(quotient)
    } else {
        Duration::ZERO
    }
}

            pub fn slow_poll_ratio(&self) -> f64 {
                self.total_slow_poll_count as f64 / self.total_poll_count as f64
            }

            /// The ratio of tasks exceeding [`long_delay_threshold`][TaskMonitor::long_delay_threshold].
            // ...
            pub fn long_delay_ratio(&self) -> f64 {
                self.total_long_delay_count as f64 / self.total_scheduled_count as f64
            }

    #[cfg(not(test))]
    pub const DEFAULT_SLOW_POLL_THRESHOLD: Duration = Duration::from_micros(50);
    #[cfg(test)]
    #[allow(missing_docs)]
    pub const DEFAULT_SLOW_POLL_THRESHOLD: Duration = Duration::from_millis(500);

    // ...
    #[cfg(not(test))]
    pub const DEFAULT_LONG_DELAY_THRESHOLD: Duration = Duration::from_micros(50);
    #[cfg(test)]
    #[allow(missing_docs)]
    pub const DEFAULT_LONG_DELAY_THRESHOLD: Duration = Duration::from_millis(500);

let mut b = TaskMonitor::builder();
b.with_slow_poll_threshold(Duration::from_millis(1))
  .with_long_delay_threshold(Duration::from_millis(1));
let monitor = b.build();