metrics-rs 与 metrique

    pub fn new(transformer: impl FnMut(&'static str) -> metrics::Key + Send + 'static) -> Self {
        TaskMetricsReporterBuilder {
            interval: DEFAULT_METRIC_SAMPLING_INTERVAL,
            metrics_transformer: Box::new(transformer),
        }
    }

    pub async fn run(mut self) {
        loop {
            self.run_once();
            tokio::time::sleep(self.interval).await;
        }
    }

macro_rules! metric_key {
    ($transform_fn:ident, $name:ident) => {
        $transform_fn(concat!("tokio_", stringify!($name)))
    };
}

metric_refs! {
    [TaskMetricRefs] [elapsed] [TaskMetrics] [()] {
        stable {
            /// The number of tasks instrumented.
            instrumented_count: Gauge<Count> [],
            // ...
            /// The total duration elapsed during polls.
            total_poll_duration: Counter<Microseconds> [],
            // ...
        }
        stable_derived {
            // ...
            /// The mean duration of polls.
            mean_poll_duration: Counter<Microseconds> [],
            /// The ratio between the number polls categorized as slow and fast.
            slow_poll_ratio: Gauge<Percent> [],
            // ...
        }
        unstable {}
        unstable_derived {}
    }
}

impl<T> MyMetricOp<T> for (&metrics::Counter, Duration) {
    fn op(self, _: T) {
        self.0
            .increment(self.1.as_micros().try_into().unwrap_or(u64::MAX));
    }
}

impl<T> MyMetricOp<T> for (&metrics::Counter, u64) {
    fn op(self, _t: T) {
        self.0.increment(self.1);
    }
}

impl<T> MyMetricOp<T> for (&metrics::Gauge, Duration) {
    fn op(self, _t: T) {
        self.0.set(self.1.as_micros() as f64);
    }
}
// ... Gauge 收 u64、usize、f64 都是 set

tokio-metrics = { version = "=0.5.2", features = ["rt", "metrics-rs-integration"] }
tokio = { version = "=1.54.1", features = ["full"] }
metrics = "=0.24.6"
metrics-exporter-prometheus = { version = "=0.17.2", default-features = false }

use std::time::{Duration, Instant};
use metrics::Key;
use metrics_exporter_prometheus::{PrometheusBuilder, PrometheusHandle};
use tokio_metrics::{TaskMetricsReporterBuilder, TaskMonitor};

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

// 10 个任务，每个 poll 两次：第一次忙 100µs（慢），yield 之后第二次立刻完成（快）
async fn round(m: &TaskMonitor) {
  for _ in 0..10 {
    tokio::spawn(m.instrument(async {
      spin(Duration::from_micros(100));
      tokio::task::yield_now().await;
    }))
    .await
    .unwrap();
  }
}

const KEEP: [&str; 6] = ["instrumented_count", "total_poll_count", "total_poll_duration", "mean_poll_duration", "slow_poll_ratio", "max_idle_duration"];

// 只打印这 6 个指标；prefix 为 "" 时打印数值行，为 "# TYPE" 时打印类型行
fn show(handle: &PrometheusHandle, prefix: &str) {
  let mut lines: Vec<String> = handle
    .render()
    .lines()
    .filter(|l| l.starts_with(prefix) && (prefix.starts_with('#') || !l.starts_with('#')))
    .filter(|l| KEEP.iter().any(|k| l.contains(&format!("tokio_{k}{{")) || l.ends_with(&format!("tokio_{k} counter")) || l.ends_with(&format!("tokio_{k} gauge"))))
    .map(String::from)
    .collect();
  lines.sort_by_key(|l| KEEP.iter().position(|k| l.contains(&format!("tokio_{k}"))));
  println!("{}", lines.join("\n"));
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  let recorder = PrometheusBuilder::new().build_recorder();
  let handle = recorder.handle();
  metrics::set_global_recorder(recorder).unwrap();

  let monitor = TaskMonitor::new();
  // 先装好 recorder，再 build：指标句柄在 build 时就取好了
  let mut reporter = TaskMetricsReporterBuilder::new(|name| Key::from_parts(name, &[("route", "search")]))
    .describe()
    .build_with_monitor(monitor.clone());

  for (i, work) in [true, true, false].into_iter().enumerate() {
    if work {
      round(&monitor).await;
    }
    reporter.run_once(); // 不用 run() 的定时循环，手动取一个区间
    println!("--- after interval {} (work={work})", i + 1);
    show(&handle, "tokio_");
  }
  println!("---");
  show(&handle, "# TYPE");
}

--- after interval 1 (work=true)
tokio_instrumented_count{route="search"} 10
tokio_total_poll_count{route="search"} 20
tokio_total_poll_duration{route="search"} 1001
tokio_mean_poll_duration{route="search"} 50
tokio_slow_poll_ratio{route="search"} 0.5
tokio_max_idle_duration{route="search"} 26
--- after interval 2 (work=true)
tokio_instrumented_count{route="search"} 10
tokio_total_poll_count{route="search"} 20
tokio_total_poll_duration{route="search"} 2006
tokio_mean_poll_duration{route="search"} 100
tokio_slow_poll_ratio{route="search"} 0.5
tokio_max_idle_duration{route="search"} 38
--- after interval 3 (work=false)
tokio_instrumented_count{route="search"} 0
tokio_total_poll_count{route="search"} 0
tokio_total_poll_duration{route="search"} 2006
tokio_mean_poll_duration{route="search"} 100
tokio_slow_poll_ratio{route="search"} NaN
tokio_max_idle_duration{route="search"} 38
---
# TYPE tokio_instrumented_count gauge
# TYPE tokio_total_poll_count gauge
# TYPE tokio_total_poll_duration counter
# TYPE tokio_mean_poll_duration counter
# TYPE tokio_slow_poll_ratio gauge
# TYPE tokio_max_idle_duration counter

#[cfg(all(feature = "rt", tokio_unstable))]
impl<T> MyMetricOp<T> for (&metrics::Histogram, crate::runtime::PollTimeHistogram) {
    fn op(self, _: T) {
        for bucket in self.1.buckets() {
            if bucket.count() > 0 {
                // Use range.start as the representative value; the metrics-rs
                // histogram handles its own bucketing from these raw values.
                self.0.record_many(
                    bucket.range_start().as_micros() as f64,
                    bucket.count() as usize,
                );
            }
        }
    }
}