稳定与不稳定两层字段

#[derive(Debug)]
pub struct RuntimeMonitor {
    /// Handle to the runtime
    runtime: runtime::RuntimeMetrics,
}

macro_rules! define_runtime_metrics {
    (
    stable {
        $(
            $(#[$($attributes:tt)*])*
            $vis:vis $name:ident: $ty:ty
        ),*
        $(,)?
    }
    unstable {
        // ... 同上
    }
    ) => {
        /// Key runtime metrics.
        #[non_exhaustive]
        #[cfg_attr(feature = "metrique-integration", metrique::unit_of_work::metrics(subfield_owned))]
        #[derive(Default, Debug, Clone)]
        pub struct RuntimeMetrics {
            $(
                $(#[$($attributes)*])*
                #[cfg_attr(docsrs, doc(cfg(feature = "rt")))]
                $vis $name: $ty,
            )*
            $(
                $(#[$($unstable_attributes)*])*
                #[cfg(tokio_unstable)]
                #[cfg_attr(docsrs, doc(cfg(all(feature = "rt", tokio_unstable))))]
                $unstable_vis $unstable_name: $unstable_ty,
            )*
        }
    };
}

            pub(crate) fn start_poll(
                &mut self,
                schedule_latency_context: Option<ScheduleLatencyContext>,
            ) -> Option<Duration> {
                self.poll_count += 1;
                let poll_started_at = self.poll_timer.as_mut().map(|poll_timer| {
                    let now = Instant::now();
                    poll_timer.poll_started_at = now;
                    now
                });
                // ...
            }

use std::time::{Duration, Instant};
use tokio_metrics::{RuntimeMetrics, RuntimeMonitor};

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

// 数 Debug 输出里的顶层字段
fn field_count(m: &RuntimeMetrics) -> usize {
  format!("{m:#?}")
    .lines()
    .filter(|l| l.starts_with("    ") && !l.starts_with("     ") && l.contains(':'))
    .count()
}

fn main() {
  let mut b = tokio::runtime::Builder::new_multi_thread();
  b.worker_threads(4).enable_all();
  #[cfg(tokio_unstable)]
  b.enable_metrics_poll_time_histogram();
  let rt = b.build().unwrap();
  let monitor = RuntimeMonitor::new(rt.handle());
  let mut iv = monitor.intervals();
  println!("tokio_unstable={} fields={}", cfg!(tokio_unstable), field_count(&RuntimeMetrics::default()));

  // 1. 从运行时外面 spawn 100 个任务
  let hs: Vec<_> = (0..100).map(|_| rt.spawn(async {})).collect();
  rt.block_on(async move {
    for h in hs {
      h.await.unwrap();
    }
    // 2. 一个任务一口气 spawn 1000 个小任务（每个忙 20µs）
    tokio::spawn(async {
      let hs: Vec<_> = (0..1000).map(|_| tokio::spawn(async { spin(Duration::from_micros(20)) })).collect();
      for h in hs {
        h.await.unwrap();
      }
    })
    .await
    .unwrap();
    // 3. 一个循环收完 1000 条已经就绪的消息
    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
    for i in 0..1000 {
      tx.send(i).unwrap();
    }
    drop(tx);
    tokio::spawn(async move { while rx.recv().await.is_some() {} }).await.unwrap();
    // 4. 10 个回环 TCP 连接
    let l = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = l.local_addr().unwrap();
    let acc = tokio::spawn(async move {
      for _ in 0..10 {
        l.accept().await.unwrap();
      }
    });
    for _ in 0..10 {
      tokio::net::TcpStream::connect(addr).await.unwrap();
    }
    acc.await.unwrap();
    // 5. 3 个阻塞任务，取样时还在睡
    for _ in 0..3 {
      tokio::task::spawn_blocking(|| std::thread::sleep(Duration::from_millis(300)));
    }
    tokio::time::sleep(Duration::from_millis(50)).await;
  });
  let m = iv.next().unwrap();
  println!(
    "stable: workers={} live={} park total/max/min={}/{}/{} busy total={:?} busy_ratio={:.2} global_queue_depth={} elapsed={:?}",
    m.workers_count, m.live_tasks_count, m.total_park_count, m.max_park_count, m.min_park_count,
    m.total_busy_duration, m.busy_ratio(), m.global_queue_depth, m.elapsed
  );
  #[cfg(tokio_unstable)]
  {
    println!(
      "polls total/max/min={}/{}/{} mean_poll={:?} worker_min/max={:?}/{:?} polls_per_park={:.1}",
      m.total_polls_count, m.max_polls_count, m.min_polls_count, m.mean_poll_duration,
      m.mean_poll_duration_worker_min, m.mean_poll_duration_worker_max, m.mean_polls_per_park()
    );
    println!(
      "remote={} local_schedule={} overflow={} steal={} steal_ops={} noop={}",
      m.num_remote_schedules, m.total_local_schedule_count, m.total_overflow_count,
      m.total_steal_count, m.total_steal_operations, m.total_noop_count
    );
    println!(
      "budget_forced_yield={} io_ready={} blocking threads/idle/queue={}/{}/{} local_queue_depth={}",
      m.budget_forced_yield_count, m.io_driver_ready_count, m.blocking_threads_count,
      m.idle_blocking_threads_count, m.blocking_queue_depth, m.total_local_queue_depth
    );
    let counts: Vec<String> = m.poll_time_histogram.buckets().iter().map(|b| b.count().to_string()).collect();
    println!("histogram buckets={} counts=[{}]", m.poll_time_histogram.buckets().len(), counts.join(","));
  }
}

tokio_unstable=false fields=10
stable: workers=4 live=0 park total/max/min=42/21/3 busy total=20.830501ms busy_ratio=0.35 global_queue_depth=0 elapsed=58.920459ms

tokio_unstable=true fields=41
stable: workers=4 live=0 park total/max/min=44/25/3 busy total=20.687664ms busy_ratio=0.35 global_queue_depth=0 elapsed=58.761916ms
polls total/max/min=1122/331/248 mean_poll=15.967µs worker_min/max=8.878µs/20.348µs polls_per_park=59.1
remote=103 local_schedule=1189 overflow=6 steal=52 steal_ops=5 noop=25
budget_forced_yield=10 io_ready=20 blocking threads/idle/queue=3/0/0 local_queue_depth=0
histogram buckets=10 counts=[1122,0,0,0,0,0,0,0,0,0]