refactor: unify metadata management into single shared state

Author: palindrom615

metrics-exporter-opentelemetry/src/description.rs

@@ -1,34 +1,29 @@
 //! An OpenTelemetry metrics exporter for `metrics`.
-mod description;
 mod instruments;
+mod metadata;
 mod storage;
 
-use crate::description::DescriptionTable;
+use crate::metadata::MetricMetadata;
 use crate::storage::OtelMetricStorage;
 use metrics::{Counter, Gauge, Histogram, Key, KeyName, Recorder, SharedString, Unit};
 use metrics_util::registry::Registry;
 use metrics_util::MetricKind;
 use opentelemetry::metrics::Meter;
-use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
 
 /// The OpenTelemetry recorder.
 pub struct OpenTelemetryRecorder {
     registry: Registry<Key, OtelMetricStorage>,
-    description_table: Arc<DescriptionTable>,
-    histogram_bounds: Arc<RwLock<HashMap<KeyName, Vec<f64>>>>,
+    metadata: MetricMetadata,
 }
 
 impl OpenTelemetryRecorder {
     /// Creates a new OpenTelemetry recorder with the given meter.
     pub fn new(meter: Meter) -> Self {
-        let description_table = Arc::new(DescriptionTable::default());
-        let histogram_bounds = Arc::new(RwLock::new(HashMap::new()));
-        let storage = OtelMetricStorage::new(meter, description_table.clone(), histogram_bounds.clone());
+        let metadata = MetricMetadata::new();
+        let storage = OtelMetricStorage::new(meter, metadata.clone());
         Self { 
             registry: Registry::new(storage), 
-            description_table,
-            histogram_bounds,
+            metadata,
         }
     }
 
@@ -37,8 +32,7 @@ impl OpenTelemetryRecorder {
         key: &KeyName,
         bounds: Vec<f64>,
     ) {
-        let mut bounds_map = self.histogram_bounds.write().unwrap();
-        bounds_map.insert(key.clone(), bounds);
+        self.metadata.set_histogram_bounds(key.clone(), bounds);
     }
 
     /// Gets a description entry for testing purposes.
@@ -47,8 +41,8 @@ impl OpenTelemetryRecorder {
         &self,
         key_name: KeyName,
         metric_kind: MetricKind,
-    ) -> Option<crate::description::DescriptionEntry> {
-        self.description_table.get_describe(key_name, metric_kind)
+    ) -> Option<crate::metadata::MetricDescription> {
+        self.metadata.get_description(&key_name, metric_kind)
     }
 }
 
@@ -59,11 +53,11 @@ impl Recorder for OpenTelemetryRecorder {
         _unit: Option<Unit>,
         _description: SharedString,
     ) {
-        self.description_table.add_describe(_key_name, MetricKind::Counter, _unit, _description);
+        self.metadata.add_description(_key_name, MetricKind::Counter, _unit, _description);
     }
 
     fn describe_gauge(&self, _key_name: KeyName, _unit: Option<Unit>, _description: SharedString) {
-        self.description_table.add_describe(_key_name, MetricKind::Gauge, _unit, _description);
+        self.metadata.add_description(_key_name, MetricKind::Gauge, _unit, _description);
     }
 
     fn describe_histogram(
@@ -72,7 +66,7 @@ impl Recorder for OpenTelemetryRecorder {
         _unit: Option<Unit>,
         _description: SharedString,
     ) {
-        self.description_table.add_describe(_key_name, MetricKind::Histogram, _unit, _description);
+        self.metadata.add_description(_key_name, MetricKind::Histogram, _unit, _description);
     }
 
     fn register_counter(&self, key: &Key, _metadata: &metrics::Metadata<'_>) -> Counter {

metrics-exporter-opentelemetry/src/lib.rs

@@ -0,0 +1,77 @@
+use metrics::{KeyName, SharedString, Unit};
+use metrics_util::MetricKind;
+use std::collections::HashMap;
+use std::sync::{Arc, PoisonError, RwLock};
+
+#[derive(Clone)]
+pub struct MetricDescription {
+    unit: Option<Unit>,
+    description: SharedString,
+}
+
+impl MetricDescription {
+    pub fn unit(&self) -> Option<Unit> {
+        self.unit
+    }
+    
+    pub fn description(&self) -> SharedString {
+        self.description.clone()
+    }
+}
+
+/// Stores all metric metadata including descriptions and histogram bounds
+#[derive(Default)]
+pub struct MetricMetadata {
+    inner: Arc<RwLock<MetricMetadataInner>>,
+}
+
+#[derive(Default)]
+struct MetricMetadataInner {
+    descriptions: HashMap<(KeyName, MetricKind), MetricDescription>,
+    histogram_bounds: HashMap<KeyName, Vec<f64>>,
+}
+
+impl MetricMetadata {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    
+    pub fn add_description(
+        &self,
+        key_name: KeyName,
+        metric_kind: MetricKind,
+        unit: Option<Unit>,
+        description: SharedString,
+    ) {
+        let new_entry = MetricDescription { unit, description };
+        let mut inner = self.inner.write().unwrap_or_else(PoisonError::into_inner);
+        inner.descriptions.insert((key_name, metric_kind), new_entry);
+    }
+    
+    pub fn get_description(
+        &self,
+        key_name: &KeyName,
+        metric_kind: MetricKind,
+    ) -> Option<MetricDescription> {
+        let inner = self.inner.read().unwrap_or_else(PoisonError::into_inner);
+        inner.descriptions.get(&(key_name.clone(), metric_kind)).cloned()
+    }
+    
+    pub fn set_histogram_bounds(&self, key_name: KeyName, bounds: Vec<f64>) {
+        let mut inner = self.inner.write().unwrap_or_else(PoisonError::into_inner);
+        inner.histogram_bounds.insert(key_name, bounds);
+    }
+    
+    pub fn get_histogram_bounds(&self, key_name: &KeyName) -> Option<Vec<f64>> {
+        let inner = self.inner.read().unwrap_or_else(PoisonError::into_inner);
+        inner.histogram_bounds.get(key_name).cloned()
+    }
+}
+
+impl Clone for MetricMetadata {
+    fn clone(&self) -> Self {
+        Self {
+            inner: Arc::clone(&self.inner),
+        }
+    }
+}

metrics-exporter-opentelemetry/src/metadata.rs

@@ -1,26 +1,20 @@
-use crate::description::{DescriptionEntry, DescriptionTable};
 use crate::instruments::{OtelCounter, OtelGauge, OtelHistogram};
+use crate::metadata::{MetricDescription, MetricMetadata};
 use metrics::{Key, KeyName};
 use metrics_util::registry::Storage;
 use metrics_util::MetricKind;
 use opentelemetry::metrics::{AsyncInstrumentBuilder, HistogramBuilder, Meter};
 use opentelemetry::KeyValue;
-use std::collections::HashMap;
-use std::sync::{Arc, PoisonError, RwLock};
+use std::sync::Arc;
 
 pub struct OtelMetricStorage {
     meter: Meter,
-    description_table: Arc<DescriptionTable>,
-    histogram_bounds: Arc<RwLock<HashMap<KeyName, Vec<f64>>>>,
+    metadata: MetricMetadata,
 }
 
 impl OtelMetricStorage {
-    pub fn new(meter: Meter, description_table: Arc<DescriptionTable>, histogram_bounds: Arc<RwLock<HashMap<KeyName, Vec<f64>>>>) -> Self {
-        Self { 
-            meter, 
-            description_table,
-            histogram_bounds,
-        }
+    pub fn new(meter: Meter, metadata: MetricMetadata) -> Self {
+        Self { meter, metadata }
     }
 
     fn get_attributes(key: &Key) -> Vec<KeyValue> {
@@ -29,28 +23,27 @@ impl OtelMetricStorage {
             .collect()
     }
 
-    fn with_description_entry<'a, I, M>(
-        description_entry: &DescriptionEntry,
+    fn with_description<'a, I, M>(
+        description: &MetricDescription,
         builder: AsyncInstrumentBuilder<'a, I, M>,
     ) -> AsyncInstrumentBuilder<'a, I, M> {
-        // let builder = builder.with_description(self.description.to_string());
-        match description_entry.unit() {
+        match description.unit() {
             Some(unit) => builder
-                .with_description(description_entry.description().to_string())
+                .with_description(description.description().to_string())
                 .with_unit(unit.as_canonical_label()),
-            None => builder.with_description(description_entry.description().to_string()),
+            None => builder.with_description(description.description().to_string()),
         }
     }
-    fn with_description_entry_histogram<'a, T>(
-        description_entry: &DescriptionEntry,
+
+    fn with_description_histogram<'a, T>(
+        description: &MetricDescription,
         builder: HistogramBuilder<'a, T>,
     ) -> HistogramBuilder<'a, T> {
-        // let builder = builder.with_description(self.description.to_string());
-        match description_entry.unit() {
+        match description.unit() {
             Some(unit) => builder
-                .with_description(description_entry.description().to_string())
+                .with_description(description.description().to_string())
                 .with_unit(unit.as_canonical_label()),
-            None => builder.with_description(description_entry.description().to_string()),
+            None => builder.with_description(description.description().to_string()),
         }
     }
 }
@@ -62,11 +55,11 @@ impl Storage<Key> for OtelMetricStorage {
 
     fn counter(&self, key: &Key) -> Self::Counter {
         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)
+        let key_name = KeyName::from(key.name().to_string());
+        let builder = if let Some(description) =
+            self.metadata.get_description(&key_name, MetricKind::Counter)
+        {
+            Self::with_description(&description, builder)
         } else {
             builder
         };
@@ -76,11 +69,11 @@ impl Storage<Key> for OtelMetricStorage {
 
     fn gauge(&self, key: &Key) -> Self::Gauge {
         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)
+        let key_name = KeyName::from(key.name().to_string());
+        let builder = if let Some(description) =
+            self.metadata.get_description(&key_name, MetricKind::Gauge)
+        {
+            Self::with_description(&description, builder)
         } else {
             builder
         };
@@ -90,26 +83,23 @@ impl Storage<Key> for OtelMetricStorage {
 
     fn histogram(&self, key: &Key) -> Self::Histogram {
         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)
+        let key_name = KeyName::from(key.name().to_string());
+
+        let builder = if let Some(description) =
+            self.metadata.get_description(&key_name, MetricKind::Histogram)
+        {
+            Self::with_description_histogram(&description, builder)
         } else {
             builder
         };
-        
+
         // Apply histogram bounds if they exist
-        let key_name = KeyName::from(key.name().to_string());
-        let builder = {
-            let bounds_map = self.histogram_bounds.read().unwrap_or_else(PoisonError::into_inner);;
-            if let Some(bounds) = bounds_map.get(&key_name) {
-                builder.with_boundaries(bounds.clone())
-            } else {
-                builder
-            }
+        let builder = if let Some(bounds) = self.metadata.get_histogram_bounds(&key_name) {
+            builder.with_boundaries(bounds)
+        } else {
+            builder
         };
-        
+
         let attributes = Self::get_attributes(key);
         Arc::new(OtelHistogram::new(builder.build(), attributes))
     }