feat(opentelemetry): implement set_histogram_bounds for custom bucket boundaries

Add support for configuring custom histogram bucket boundaries in the OpenTelemetry exporter.
This allows users to define specific bucket boundaries for individual metrics, enabling
better histogram resolution tailored to expected value distributions.

- Add histogram_bounds HashMap shared between recorder and storage via Arc<RwLock<>>
- Implement set_histogram_bounds() method to configure boundaries before histogram creation
- Apply custom boundaries when creating histograms in OtelMetricStorage
- Add comprehensive test coverage for custom histogram bounds functionality
- Fix integration tests to use InMemoryMetricExporter with proper assertions

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: palindrom615

metrics-exporter-opentelemetry/src/lib.rs

@@ -9,22 +9,38 @@ use metrics::{Counter, Gauge, Histogram, Key, KeyName, Recorder, SharedString, U
 use metrics_util::registry::Registry;
 use metrics_util::MetricKind;
 use opentelemetry::metrics::Meter;
-use std::sync::Arc;
+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>>>>,
 }
 
 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 storage = OtelMetricStorage::new(meter, description_table.clone());
-        Self { registry: Registry::new(storage), description_table }
+        let histogram_bounds = Arc::new(RwLock::new(HashMap::new()));
+        let storage = OtelMetricStorage::new(meter, description_table.clone(), histogram_bounds.clone());
+        Self { 
+            registry: Registry::new(storage), 
+            description_table,
+            histogram_bounds,
+        }
     }
 
+    pub fn set_histogram_bounds(
+        &self,
+        key: &KeyName,
+        bounds: Vec<f64>,
+    ) {
+        let mut bounds_map = self.histogram_bounds.write().unwrap();
+        bounds_map.insert(key.clone(), bounds);
+    }
+    
     /// Gets a description entry for testing purposes.
     #[cfg(test)]
     pub fn get_description(

metrics-exporter-opentelemetry/src/storage.rs

@@ -5,16 +5,22 @@ use metrics_util::registry::Storage;
 use metrics_util::MetricKind;
 use opentelemetry::metrics::{AsyncInstrumentBuilder, HistogramBuilder, Meter};
 use opentelemetry::KeyValue;
-use std::sync::Arc;
+use std::collections::HashMap;
+use std::sync::{Arc, PoisonError, RwLock};
 
 pub struct OtelMetricStorage {
     meter: Meter,
     description_table: Arc<DescriptionTable>,
+    histogram_bounds: Arc<RwLock<HashMap<KeyName, Vec<f64>>>>,
 }
 
 impl OtelMetricStorage {
-    pub fn new(meter: Meter, description_table: Arc<DescriptionTable>) -> Self {
-        Self { meter, description_table }
+    pub fn new(meter: Meter, description_table: Arc<DescriptionTable>, histogram_bounds: Arc<RwLock<HashMap<KeyName, Vec<f64>>>>) -> Self {
+        Self { 
+            meter, 
+            description_table,
+            histogram_bounds,
+        }
     }
 
     fn get_attributes(key: &Key) -> Vec<KeyValue> {
@@ -92,6 +98,18 @@ impl Storage<Key> for OtelMetricStorage {
         } 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 attributes = Self::get_attributes(key);
         Arc::new(OtelHistogram::new(builder.build(), attributes))
     }

metrics-exporter-opentelemetry/tests/integration_test.rs

@@ -391,3 +391,72 @@ fn test_metrics_with_multiple_labels() {
     assert!(attrs.iter().any(|a| a.key == Key::from("path") && a.value == Value::from("/api/v1/users")));
     assert_eq!(point.value(), 5, "Counter value should be 5");
 }
+
+#[test]
+fn test_histogram_with_custom_bounds() {
+    // Given: OpenTelemetry recorder with custom histogram bounds
+    let exporter = InMemoryMetricExporter::default();
+    let reader = PeriodicReader::builder(exporter.clone())
+        .with_interval(Duration::from_millis(100))
+        .build();
+    let provider = SdkMeterProvider::builder().with_reader(reader).build();
+    let meter = provider.meter("test_meter");
+    let recorder = OpenTelemetryRecorder::new(meter);
+    
+    // When: Custom bounds are set for a histogram before it's created
+    recorder.set_histogram_bounds(
+        &metrics::KeyName::from("latency"),
+        vec![0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]
+    );
+    
+    // And: Histogram is registered and values are recorded
+    let key = metrics::Key::from_name("latency");
+    let metadata = metrics::Metadata::new("test", metrics::Level::INFO, Some("latency"));
+    let histogram = recorder.register_histogram(&key, &metadata);
+    histogram.record(0.03);
+    histogram.record(0.12);
+    histogram.record(0.75);
+    histogram.record(3.5);
+    
+    provider.force_flush().unwrap();
+
+    // Then: Histogram should be recorded with values
+    let metrics = exporter.get_finished_metrics().unwrap();
+    let latency_metric = metrics.last().unwrap().scope_metrics()
+        .flat_map(|sm| sm.metrics())
+        .find(|m| m.name() == "latency")
+        .expect("latency metric should exist");
+    
+    let AggregatedMetrics::F64(metric_data) = latency_metric.data() else {
+        panic!("Histogram should be F64");
+    };
+    let MetricData::Histogram(hist_data) = metric_data else {
+        panic!("Should be Histogram type");
+    };
+    
+    let point = hist_data.data_points().next().expect("Should have data point");
+    
+    // Verify the histogram has recorded values
+    assert_eq!(point.count(), 4, "Should have 4 recordings");
+    assert_eq!(point.sum(), 0.03 + 0.12 + 0.75 + 3.5, "Sum should be correct");
+    
+    // Check bucket boundaries are applied (9 boundaries create 10 buckets)
+    let boundaries: Vec<_> = point.bounds().collect();
+    assert_eq!(boundaries.len(), 9, "Should have 9 boundaries");
+    assert_eq!(boundaries, vec![0.01, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]);
+    
+    // Check bucket counts
+    let counts: Vec<_> = point.bucket_counts().collect();
+    assert_eq!(counts.len(), 10, "Should have 10 buckets");
+    // Values: 0.03 (bucket 1), 0.12 (bucket 3), 0.75 (bucket 5), 3.5 (bucket 7)
+    assert_eq!(counts[0], 0, "Bucket [0, 0.01) should be empty");
+    assert_eq!(counts[1], 1, "Bucket [0.01, 0.05) should have 1 value (0.03)");
+    assert_eq!(counts[2], 0, "Bucket [0.05, 0.1) should be empty");
+    assert_eq!(counts[3], 1, "Bucket [0.1, 0.25) should have 1 value (0.12)");
+    assert_eq!(counts[4], 0, "Bucket [0.25, 0.5) should be empty");
+    assert_eq!(counts[5], 1, "Bucket [0.5, 1.0) should have 1 value (0.75)");
+    assert_eq!(counts[6], 0, "Bucket [1.0, 2.5) should be empty");
+    assert_eq!(counts[7], 1, "Bucket [2.5, 5.0) should have 1 value (3.5)");
+    assert_eq!(counts[8], 0, "Bucket [5.0, 10.0) should be empty");
+    assert_eq!(counts[9], 0, "Bucket [10.0, +∞) should be empty");
+}