fix: support description

Author: palindrom615

metrics-exporter-opentelemetry/src/description.rs

@@ -0,0 +1,54 @@
+use metrics::{KeyName, SharedString, Unit};
+use metrics_util::MetricKind;
+
+use std::collections::HashMap;
+use std::sync::{PoisonError, RwLock};
+
+#[derive(Clone)]
+pub struct DescriptionEntry {
+    unit: Option<Unit>,
+    description: SharedString,
+}
+
+impl DescriptionEntry {
+    pub fn unit(&self) -> Option<Unit> {
+        self.unit
+    }
+    pub fn description(&self) -> SharedString {
+        self.description.clone()
+    }
+}
+
+#[derive(Default)]
+pub struct DescriptionTable {
+    table: RwLock<HashMap<(KeyName, MetricKind), DescriptionEntry>>,
+}
+
+impl DescriptionTable {
+    pub fn add_describe(
+        &self,
+        key_name: KeyName,
+        metric_kind: MetricKind,
+        unit: Option<Unit>,
+        description: SharedString,
+    ) {
+        let new_entry = DescriptionEntry { unit, description };
+        self.table
+            .write()
+            .unwrap_or_else(PoisonError::into_inner)
+            .entry((key_name, metric_kind))
+            .and_modify(|e| {
+                *e = new_entry.clone();
+            })
+            .or_insert(new_entry);
+    }
+
+    pub fn get_describe(
+        &self,
+        key_name: KeyName,
+        metric_kind: MetricKind,
+    ) -> Option<DescriptionEntry> {
+        let table = self.table.read().unwrap_or_else(PoisonError::into_inner);
+        table.get(&(key_name, metric_kind)).cloned()
+    }
+}

metrics-exporter-opentelemetry/src/lib.rs

@@ -1,34 +1,53 @@
 //! An OpenTelemetry metrics exporter for `metrics`.
+mod description;
 mod instruments;
 mod storage;
 
+use crate::description::DescriptionTable;
+use crate::storage::OtelMetricStorage;
 use metrics::{Counter, Gauge, Histogram, Key, KeyName, Recorder, SharedString, Unit};
-use metrics_util::registry::{Registry, Storage};
+use metrics_util::registry::Registry;
+use metrics_util::MetricKind;
 use opentelemetry::metrics::Meter;
-use crate::storage::OtelMetricStorage;
+use std::sync::Arc;
 
 /// The OpenTelemetry recorder.
 pub struct OpenTelemetryRecorder {
     registry: Registry<Key, OtelMetricStorage>,
+    description_table: Arc<DescriptionTable>,
 }
 
 impl OpenTelemetryRecorder {
     /// Creates a new OpenTelemetry recorder with the given meter.
     pub fn new(meter: Meter) -> Self {
-        let storage = OtelMetricStorage::new(meter);
-        Self {
-            registry: Registry::new(storage),
-        }
+        let description_table = Arc::new(DescriptionTable::default());
+        let storage = OtelMetricStorage::new(meter, description_table.clone());
+        Self { registry: Registry::new(storage), description_table }
+    }
+
+    /// Gets a description entry for testing purposes.
+    #[cfg(test)]
+    pub fn get_description(
+        &self,
+        key_name: KeyName,
+        metric_kind: MetricKind,
+    ) -> Option<crate::description::DescriptionEntry> {
+        self.description_table.get_describe(key_name, metric_kind)
     }
 }
 
 impl Recorder for OpenTelemetryRecorder {
-    fn describe_counter(&self, _key_name: KeyName, _unit: Option<Unit>, _description: SharedString) {
-        // Descriptions are handled when creating instruments
+    fn describe_counter(
+        &self,
+        _key_name: KeyName,
+        _unit: Option<Unit>,
+        _description: SharedString,
+    ) {
+        self.description_table.add_describe(_key_name, MetricKind::Counter, _unit, _description);
     }
 
     fn describe_gauge(&self, _key_name: KeyName, _unit: Option<Unit>, _description: SharedString) {
-        // Descriptions are handled when creating instruments
+        self.description_table.add_describe(_key_name, MetricKind::Gauge, _unit, _description);
     }
 
     fn describe_histogram(
@@ -37,24 +56,18 @@ impl Recorder for OpenTelemetryRecorder {
         _unit: Option<Unit>,
         _description: SharedString,
     ) {
-        // Descriptions are handled when creating instruments
+        self.description_table.add_describe(_key_name, MetricKind::Histogram, _unit, _description);
     }
 
     fn register_counter(&self, key: &Key, _metadata: &metrics::Metadata<'_>) -> Counter {
-        self.registry.get_or_create_counter(key, |c| {
-            Counter::from_arc(c.clone())
-        })
+        self.registry.get_or_create_counter(key, |c| Counter::from_arc(c.clone()))
     }
 
     fn register_gauge(&self, key: &Key, _metadata: &metrics::Metadata<'_>) -> Gauge {
-        self.registry.get_or_create_gauge(key, |g| {
-            Gauge::from_arc(g.clone())
-        })
+        self.registry.get_or_create_gauge(key, |g| Gauge::from_arc(g.clone()))
     }
 
     fn register_histogram(&self, key: &Key, _metadata: &metrics::Metadata<'_>) -> Histogram {
-        self.registry.get_or_create_histogram(key, |h| {
-            Histogram::from_arc(h.clone())
-        })
+        self.registry.get_or_create_histogram(key, |h| Histogram::from_arc(h.clone()))
     }
-}
+}

metrics-exporter-opentelemetry/src/storage.rs

@@ -1,24 +1,52 @@
-use std::sync::Arc;
-use opentelemetry::KeyValue;
-use opentelemetry::metrics::Meter;
-use metrics::Key;
-use metrics_util::registry::Storage;
+use crate::description::{DescriptionEntry, DescriptionTable};
 use crate::instruments::{OtelCounter, OtelGauge, OtelHistogram};
+use metrics::{Key, KeyName};
+use metrics_util::registry::Storage;
+use metrics_util::MetricKind;
+use opentelemetry::metrics::{AsyncInstrumentBuilder, HistogramBuilder, Meter};
+use opentelemetry::KeyValue;
+use std::sync::Arc;
 
 pub struct OtelMetricStorage {
     meter: Meter,
+    description_table: Arc<DescriptionTable>,
 }
 
 impl OtelMetricStorage {
-    pub fn new(meter: Meter) -> Self {
-        Self { meter }
+    pub fn new(meter: Meter, description_table: Arc<DescriptionTable>) -> Self {
+        Self { meter, description_table }
     }
 
     fn get_attributes(key: &Key) -> Vec<KeyValue> {
         key.labels()
             .map(|label| KeyValue::new(label.key().to_string(), label.value().to_string()))
             .collect()
     }
+
+    fn with_description_entry<'a, I, M>(
+        description_entry: &DescriptionEntry,
+        builder: AsyncInstrumentBuilder<'a, I, M>,
+    ) -> AsyncInstrumentBuilder<'a, I, M> {
+        // let builder = builder.with_description(self.description.to_string());
+        match description_entry.unit() {
+            Some(unit) => builder
+                .with_description(description_entry.description().to_string())
+                .with_unit(unit.as_canonical_label()),
+            None => builder.with_description(description_entry.description().to_string()),
+        }
+    }
+    fn with_description_entry_histogram<'a, T>(
+        description_entry: &DescriptionEntry,
+        builder: HistogramBuilder<'a, T>,
+    ) -> HistogramBuilder<'a, T> {
+        // let builder = builder.with_description(self.description.to_string());
+        match description_entry.unit() {
+            Some(unit) => builder
+                .with_description(description_entry.description().to_string())
+                .with_unit(unit.as_canonical_label()),
+            None => builder.with_description(description_entry.description().to_string()),
+        }
+    }
 }
 
 impl Storage<Key> for OtelMetricStorage {
@@ -27,28 +55,44 @@ impl Storage<Key> for OtelMetricStorage {
     type Histogram = Arc<OtelHistogram>;
 
     fn counter(&self, key: &Key) -> Self::Counter {
-        let otel_counter_builder = self
-            .meter
-            .u64_observable_counter(key.name().to_string());
+        let builder = self.meter.u64_observable_counter(key.name().to_string());
+        let description = self
+            .description_table
+            .get_describe(KeyName::from(key.name().to_string()), MetricKind::Counter);
+        let builder = if let Some(description) = description {
+            Self::with_description_entry(&description, builder)
+        } else {
+            builder
+        };
         let attributes = Self::get_attributes(key);
-        Arc::new(OtelCounter::new(otel_counter_builder, attributes))
+        Arc::new(OtelCounter::new(builder, attributes))
     }
 
     fn gauge(&self, key: &Key) -> Self::Gauge {
-        let builder = self
-            .meter
-            .f64_observable_gauge(key.name().to_string());
+        let builder = self.meter.f64_observable_gauge(key.name().to_string());
+        let description = self
+            .description_table
+            .get_describe(KeyName::from(key.name().to_string()), MetricKind::Gauge);
+        let builder = if let Some(description) = description {
+            Self::with_description_entry(&description, builder)
+        } else {
+            builder
+        };
         let attributes = Self::get_attributes(key);
         Arc::new(OtelGauge::new(builder, attributes))
     }
 
     fn histogram(&self, key: &Key) -> Self::Histogram {
-        let histogram = self
-            .meter
-            .f64_histogram(key.name().to_string())
-            .build();
+        let builder = self.meter.f64_histogram(key.name().to_string());
+        let description = self
+            .description_table
+            .get_describe(KeyName::from(key.name().to_string()), MetricKind::Histogram);
+        let builder = if let Some(description) = description {
+            Self::with_description_entry_histogram(&description, builder)
+        } else {
+            builder
+        };
         let attributes = Self::get_attributes(key);
-        Arc::new(OtelHistogram::new(histogram, attributes))
-
+        Arc::new(OtelHistogram::new(builder.build(), attributes))
     }
 }