refactor(metrics): modularize collectors and add comprehensive metrics support (#2208)

Co-authored-by: overtrue <anzhengchao@gmail.com>
Co-authored-by: heihutu <heihutu@gmail.com>

crates/metrics/src/format.rs

@@ -20,21 +20,50 @@
 use crate::MetricType;
 use metrics::{counter, describe_counter, describe_gauge, describe_histogram, gauge};
 use std::borrow::Cow;
+use std::collections::HashMap;
+use std::sync::{Mutex, OnceLock};
+
+static NAME_CACHE: OnceLock<Mutex<HashMap<String, &'static str>>> = OnceLock::new();
+static HELP_CACHE: OnceLock<Mutex<HashMap<String, &'static str>>> = OnceLock::new();
+
+fn intern_string(cache: &OnceLock<Mutex<HashMap<String, &'static str>>>, value: &str) -> &'static str {
+    let cache = cache.get_or_init(Default::default);
+    let mut cache = match cache.lock() {
+        Ok(guard) => guard,
+        Err(poisoned) => poisoned.into_inner(),
+    };
+
+    if let Some(existing) = cache.get(value) {
+        existing
+    } else {
+        let value = Box::leak(value.to_string().into_boxed_str());
+        cache.insert(value.to_string(), value);
+        value
+    }
+}
+
+fn into_static_str(cache: &OnceLock<Mutex<HashMap<String, &'static str>>>, value: &str) -> &'static str {
+    intern_string(cache, value)
+}
 
 /// Report metrics using the `metrics` crate.
 ///
 /// This function iterates over the provided metrics and reports them using
 /// the `metrics` crate's API. This allows integration with various metrics
 /// exporters (e.g., Prometheus) that are configured globally.
+///
 pub fn report_metrics(metrics: &[PrometheusMetric]) {
     for metric in metrics {
+        let name = into_static_str(&NAME_CACHE, &metric.name);
+        let help = into_static_str(&HELP_CACHE, &metric.help);
+
         // Register metric description (help text)
         // Note: In a real-world scenario, descriptions should ideally be registered once at startup.
         // However, the `metrics` crate handles duplicate registrations gracefully.
         match metric.metric_type {
-            MetricType::Counter => describe_counter!(metric.name, metric.help),
-            MetricType::Gauge => describe_gauge!(metric.name, metric.help),
-            MetricType::Histogram => describe_histogram!(metric.name, metric.help),
+            MetricType::Counter => describe_counter!(name, help),
+            MetricType::Gauge => describe_gauge!(name, help),
+            MetricType::Histogram => describe_histogram!(name, help),
         }
 
         // Convert labels to the format expected by `metrics` crate
@@ -50,15 +79,15 @@ pub fn report_metrics(metrics: &[PrometheusMetric]) {
                 //
                 // Since `metrics` 0.21+, `Counter` has an `absolute` method which sets the counter to a specific value.
                 // This is useful for mirroring an external counter.
-                let counter = counter!(metric.name, &labels);
+                let counter = counter!(name, &labels);
                 counter.absolute(metric.value as u64);
             }
             MetricType::Gauge => {
-                let gauge = gauge!(metric.name, &labels);
+                let gauge = gauge!(name, &labels);
                 gauge.set(metric.value);
             }
             MetricType::Histogram => {
-                let histogram = metrics::histogram!(metric.name, &labels);
+                let histogram = metrics::histogram!(name, &labels);
                 histogram.record(metric.value);
             }
         }
@@ -67,17 +96,17 @@ pub fn report_metrics(metrics: &[PrometheusMetric]) {
 
 /// A single Prometheus metric with labels and value.
 ///
-/// This struct is optimized for performance by using `&'static str` for
-/// the name and help text, which are typically compile-time constants.
+/// This struct is optimized for performance by using `Cow<'static, str>` for
+/// the name and help text, which allows both static strings and owned strings.
 /// Labels use `Cow<'static, str>` to avoid allocations when possible.
 #[derive(Debug, Clone)]
 pub struct PrometheusMetric {
     /// The metric name (e.g., "http_requests_total").
-    pub name: &'static str,
+    pub name: Cow<'static, str>,
     /// The type of this metric (counter, gauge, or histogram).
     pub metric_type: MetricType,
     /// Human-readable description shown in Prometheus UI.
-    pub help: &'static str,
+    pub help: Cow<'static, str>,
     /// Key-value label pairs for this metric instance.
     /// Uses Cow to avoid allocations for static label keys.
     pub labels: Vec<(&'static str, Cow<'static, str>)>,
@@ -92,9 +121,39 @@ impl PrometheusMetric {
     #[inline]
     pub const fn new(name: &'static str, metric_type: MetricType, help: &'static str, value: f64) -> Self {
         Self {
-            name,
+            name: Cow::Borrowed(name),
             metric_type,
-            help,
+            help: Cow::Borrowed(help),
+            labels: Vec::new(),
+            value,
+        }
+    }
+
+    /// Creates a new metric with owned strings for name and help.
+    ///
+    /// Use this when the metric name or help text is dynamically generated.
+    #[inline]
+    pub fn new_owned(name: String, metric_type: MetricType, help: String, value: f64) -> Self {
+        Self {
+            name: Cow::Owned(name),
+            metric_type,
+            help: Cow::Owned(help),
+            labels: Vec::new(),
+            value,
+        }
+    }
+
+    /// Creates a new metric from a MetricDescriptor.
+    ///
+    /// This is the recommended way to create metrics when using MetricDescriptor
+    /// from the metrics_type module.
+    #[inline]
+    pub fn from_descriptor(descriptor: &crate::MetricDescriptor, value: f64) -> Self {
+        let help = intern_string(&HELP_CACHE, &descriptor.help);
+        Self {
+            name: Cow::Owned(descriptor.get_full_metric_name()),
+            metric_type: descriptor.metric_type,
+            help: Cow::Borrowed(help),
             labels: Vec::new(),
             value,
         }