Integrate derived metrics with metrics.rs (#104)

Author: jkosh44

src/derived_metrics.rs

@@ -0,0 +1,37 @@
+macro_rules! derived_metrics {
+    (
+        [$metrics_name:ty] {
+            stable {
+                $(
+                    $(#[$($attributes:tt)*])*
+                    $vis:vis fn $name:ident($($args:tt)*) -> $ty:ty $body:block
+                )*
+            }
+            unstable {
+                $(
+                    $(#[$($unstable_attributes:tt)*])*
+                    $unstable_vis:vis fn $unstable_name:ident($($unstable_args:tt)*) -> $unstable_ty:ty $unstable_body:block
+                )*
+            }
+        }
+    ) => {
+        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),)*];
+            #[cfg(all(test, tokio_unstable, feature = "metrics-rs-integration"))]
+            const UNSTABLE_DERIVED_METRICS: &[&str] = &[$(stringify!($unstable_name),)*];
+        }
+    };
+}
+
+pub(crate) use derived_metrics;

src/lib.rs

@@ -179,6 +179,7 @@ cfg_rt! {
 )]
 pub use runtime::metrics_rs_integration::{RuntimeMetricsReporter, RuntimeMetricsReporterBuilder};
 
+mod derived_metrics;
 #[cfg(all(feature = "rt", feature = "metrics-rs-integration"))]
 mod metrics_rs;
 mod task;

src/metrics_rs.rs

@@ -76,23 +76,44 @@ macro_rules! metric_refs {
             ),*
             $(,)?
          }
+         stable_derived {
+             $(
+                #[doc = $derived_doc:tt]
+                $derived_name:ident: $derived_kind:tt <$derived_unit:ident> $derived_opts:tt
+            ),*
+            $(,)?
+         }
          unstable {
             $(
                 #[doc = $unstable_doc:tt]
                 $unstable_name:ident: $unstable_kind:tt <$unstable_unit:ident> $unstable_opts:tt
             ),*
             $(,)?
          }
+         unstable_derived {
+             $(
+                #[doc = $unstable_derived_doc:tt]
+                $unstable_derived_name:ident: $unstable_derived_kind:tt <$unstable_derived_unit:ident> $unstable_derived_opts:tt
+            ),*
+            $(,)?
+         }
         }
   ) => {
         struct $struct_name {
             $(
                 $name: crate::metrics_rs::kind_to_type!($kind),
             )*
+            $(
+                $derived_name: crate::metrics_rs::kind_to_type!($derived_kind),
+            )*
             $(
                 #[cfg(tokio_unstable)]
                 $unstable_name: crate::metrics_rs::kind_to_type!($unstable_kind),
             )*
+            $(
+                #[cfg(tokio_unstable)]
+                $unstable_derived_name: crate::metrics_rs::kind_to_type!($unstable_derived_kind),
+            )*
         }
 
         impl $struct_name {
@@ -101,14 +122,30 @@ macro_rules! metric_refs {
                     $(
                         $name: crate::metrics_rs::capture_metric_ref!(transform_fn, $name: $kind $opts),
                     )*
+                    $(
+                        $derived_name: crate::metrics_rs::capture_metric_ref!(transform_fn, $derived_name: $derived_kind $derived_opts),
+                    )*
                     $(
                         #[cfg(tokio_unstable)]
                         $unstable_name: crate::metrics_rs::capture_metric_ref!(transform_fn, $unstable_name: $unstable_kind $unstable_opts),
                     )*
+                    $(
+                        #[cfg(tokio_unstable)]
+                        $unstable_derived_name: crate::metrics_rs::capture_metric_ref!(transform_fn, $unstable_derived_name: $unstable_derived_kind $unstable_derived_opts),
+                    )*
                 }
             }
 
             fn emit(&self, metrics: $metrics_name, emit_arg: $emit_arg_type) {
+                // Emit derived metrics before base metrics because emitting base metrics may move
+                // out of `$metrics`.
+                $(
+                    crate::metrics_rs::MyMetricOp::op((&self.$derived_name, metrics.$derived_name()), emit_arg);
+                )*
+                $(
+                    #[cfg(tokio_unstable)]
+                    crate::metrics_rs::MyMetricOp::op((&self.$unstable_derived_name, metrics.$unstable_derived_name()), emit_arg);
+                )*
                 $(
                     crate::metrics_rs::MyMetricOp::op((&self.$name, metrics.$name), emit_arg);
                 )*
@@ -122,10 +159,17 @@ macro_rules! metric_refs {
                 $(
                     crate::metrics_rs::describe_metric_ref!(transform_fn, $doc, $name: $kind<$unit> $opts);
                 )*
+                $(
+                    crate::metrics_rs::describe_metric_ref!(transform_fn, $derived_doc, $derived_name: $derived_kind<$derived_unit> $derived_opts);
+                )*
                 $(
                     #[cfg(tokio_unstable)]
                     crate::metrics_rs::describe_metric_ref!(transform_fn, $unstable_doc, $unstable_name: $unstable_kind<$unstable_unit> $unstable_opts);
                 )*
+                $(
+                    #[cfg(tokio_unstable)]
+                    crate::metrics_rs::describe_metric_ref!(transform_fn, $unstable_derived_doc, $unstable_derived_name: $unstable_derived_kind<$unstable_derived_unit> $unstable_derived_opts);
+                )*
             }
         }
 
@@ -161,6 +205,28 @@ macro_rules! metric_refs {
                 panic!("missing metric {:?}", line);
             }
         }
+
+        #[test]
+        fn test_no_derived_metrics_missing() {
+            // test that no derived metrics are missing.
+            for derived_metric in <$metrics_name>::DERIVED_METRICS {
+                $(
+                    if *derived_metric == stringify!($derived_name) {
+                        continue
+                    }
+                );*
+                panic!("missing metric {:?}", derived_metric);
+            }
+            #[cfg(tokio_unstable)]
+            for unstable_derived_metric in <$metrics_name>::UNSTABLE_DERIVED_METRICS {
+                $(
+                    if *unstable_derived_metric == stringify!($unstable_derived_name) {
+                        continue
+                    }
+                );*
+                panic!("missing metric {:?}", unstable_derived_metric);
+            }
+        }
     }
 }
 
@@ -205,6 +271,12 @@ impl<T> MyMetricOp<T> for (&metrics::Gauge, usize) {
     }
 }
 
+impl<T> MyMetricOp<T> for (&metrics::Gauge, f64) {
+    fn op(self, _t: T) {
+        self.0.set(self.1);
+    }
+}
+
 #[cfg(tokio_unstable)]
 impl MyMetricOp<&tokio::runtime::RuntimeMetrics> for (&metrics::Histogram, Vec<u64>) {
     fn op(self, tokio: &tokio::runtime::RuntimeMetrics) {

src/runtime.rs

@@ -1,5 +1,6 @@
 use std::time::{Duration, Instant};
 use tokio::runtime;
+use crate::derived_metrics::derived_metrics;
 
 #[cfg(feature = "metrics-rs-integration")]
 pub(crate) mod metrics_rs_integration;
@@ -1567,20 +1568,24 @@ impl Worker {
     }
 }
 
-impl RuntimeMetrics {
-    /// Returns the ratio of the [`RuntimeMetrics::total_polls_count`] to the [`RuntimeMetrics::total_noop_count`].
-    #[cfg(tokio_unstable)]
-    pub fn mean_polls_per_park(&self) -> f64 {
-        let total_park_count = self.total_park_count - self.total_noop_count;
-        if total_park_count == 0 {
-            0.0
-        } else {
-            self.total_polls_count as f64 / total_park_count as f64
+derived_metrics!(
+    [RuntimeMetrics] {
+        stable {
+            /// Returns the ratio of the [`RuntimeMetrics::total_busy_duration`] to the [`RuntimeMetrics::elapsed`].
+            pub fn busy_ratio(&self) -> f64 {
+                self.total_busy_duration.as_nanos() as f64 / self.elapsed.as_nanos() as f64
+            }
+        }
+        unstable {
+            /// Returns the ratio of the [`RuntimeMetrics::total_polls_count`] to the [`RuntimeMetrics::total_noop_count`].
+            pub fn mean_polls_per_park(&self) -> f64 {
+                let total_park_count = self.total_park_count - self.total_noop_count;
+                if total_park_count == 0 {
+                    0.0
+                } else {
+                    self.total_polls_count as f64 / total_park_count as f64
+                }
+            }
         }
     }
-
-    /// Returns the ratio of the [`RuntimeMetrics::total_busy_duration`] to the [`RuntimeMetrics::elapsed`].
-    pub fn busy_ratio(&self) -> f64 {
-        self.total_busy_duration.as_nanos() as f64 / self.elapsed.as_nanos() as f64
-    }
-}
+);

src/runtime/metrics_rs_integration.rs

@@ -264,6 +264,10 @@ metric_refs! {
             /// The number of tasks currently scheduled in the runtime's global queue
             global_queue_depth: Gauge<Count> [],
         }
+        stable_derived {
+            /// The ratio of the [`RuntimeMetrics::total_busy_duration`] to the [`RuntimeMetrics::elapsed`].
+            busy_ratio: Gauge<Percent> [],
+        }
         unstable {
             /// The average duration of a single invocation of poll on a task
             mean_poll_duration: Gauge<Microseconds> [],
@@ -330,6 +334,10 @@ metric_refs! {
             /// Returns the number of ready events processed by the runtime’s I/O driver
             io_driver_ready_count: Counter<Count> [],
         }
+        unstable_derived {
+            /// The ratio of the [`RuntimeMetrics::total_polls_count`] to the [`RuntimeMetrics::total_noop_count`].
+            mean_polls_per_park: Gauge<Percent> [],
+        }
     }
 }