feat: add metrics-exporter-opentelemetry crate

Author: palindrom615

Cargo.lock

@@ -4,6 +4,7 @@ members = [
   "metrics",
   "metrics-benchmark",
   "metrics-exporter-dogstatsd",
+  "metrics-exporter-opentelemetry",
   "metrics-exporter-prometheus",
   "metrics-exporter-tcp",
   "metrics-observer",
@@ -48,6 +49,10 @@ ndarray = { version = "0.16", default-features = false }
 ndarray-stats = { version = "0.6", default-features = false }
 noisy_float = { version = "0.2", default-features = false }
 once_cell = { version = "1", default-features = false, features = ["std"] }
+opentelemetry = { version = "0.30", default-features = false }
+opentelemetry_sdk = { version = "0.30", default-features = false }
+opentelemetry-otlp = { version = "0.30", default-features = false }
+opentelemetry-stdout = { version = "0.30", default-features = false }
 ordered-float = { version = "4.2", default-features = false }
 parking_lot = { version = "0.12", default-features = false }
 portable-atomic = { version = "1", default-features = false }

Cargo.toml

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Initial release of OpenTelemetry metrics exporter for `metrics`
+- Support for counters, gauges, and histograms
+- Attribute/label support

metrics-exporter-opentelemetry/CHANGELOG.md

@@ -0,0 +1,26 @@
+[package]
+name = "metrics-exporter-opentelemetry"
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.75.0"
+
+description = "A metrics-compatible exporter for sending metrics to OpenTelemetry collectors."
+license = { workspace = true }
+authors = ["Metrics Contributors"]
+repository = { workspace = true }
+homepage = { workspace = true }
+documentation = "https://docs.rs/metrics-exporter-opentelemetry"
+readme = "README.md"
+
+categories = ["development-tools::debugging"]
+keywords = ["metrics", "telemetry", "opentelemetry", "otel", "observability"]
+
+[dependencies]
+metrics = { version = "^0.24", path = "../metrics" }
+metrics-util = { version = "^0.20", path = "../metrics-util", default-features = false, features = ["registry"] }
+opentelemetry = { workspace = true, features = ["metrics"] }
+portable-atomic = { workspace = true, features = ["float", "critical-section"] }
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]

metrics-exporter-opentelemetry/Cargo.toml

@@ -0,0 +1,62 @@
+# metrics-exporter-opentelemetry
+
+[![Documentation](https://docs.rs/metrics-exporter-opentelemetry/badge.svg)](https://docs.rs/metrics-exporter-opentelemetry)
+
+A [`metrics`][metrics] exporter for [OpenTelemetry].
+
+## Features
+
+- Export metrics to OpenTelemetry collectors using OTLP
+- Support for counters, gauges, and histograms
+- Integration with the OpenTelemetry SDK
+- Configurable export intervals and endpoints
+
+## Usage
+
+```rust
+use metrics::{counter, gauge, histogram};
+use metrics_exporter_opentelemetry::OpenTelemetryBuilder;
+use opentelemetry_otlp::WithExportConfig;
+use opentelemetry_sdk::{
+    metrics::{PeriodicReader, SdkMeterProvider},
+    runtime,
+};
+
+// Configure OpenTelemetry exporter
+let exporter = opentelemetry_otlp::MetricExporter::builder()
+    .with_tonic()
+    .with_endpoint("http://localhost:4317")
+    .build()?;
+
+// Create a periodic reader
+let reader = PeriodicReader::builder(exporter, runtime::Tokio)
+    .with_interval(Duration::from_secs(10))
+    .build();
+
+// Build the meter provider
+let provider = SdkMeterProvider::builder()
+    .with_reader(reader)
+    .build();
+
+// Install the metrics exporter
+OpenTelemetryBuilder::new()
+    .with_meter_provider(provider)
+    .install()?;
+
+// Now you can use the metrics macros
+counter!("requests_total").increment(1);
+gauge!("cpu_usage").set(0.75);
+histogram!("request_duration").record(0.234);
+```
+
+## Examples
+
+- [`opentelemetry_push`](examples/opentelemetry_push.rs): Demonstrates exporting metrics to an OpenTelemetry collector
+- [`opentelemetry_stdout`](examples/opentelemetry_stdout.rs): Shows metrics export to stdout for debugging
+
+## License
+
+This project is licensed under the MIT license.
+
+[metrics]: https://github.com/metrics-rs/metrics
+[OpenTelemetry]: https://opentelemetry.io/

metrics-exporter-opentelemetry/README.md

@@ -0,0 +1,95 @@
+//! OpenTelemetry instrument wrappers for metrics traits.
+
+use metrics::{CounterFn, GaugeFn, HistogramFn};
+use opentelemetry::metrics::{
+    AsyncInstrumentBuilder, Histogram, ObservableCounter, ObservableGauge,
+};
+use opentelemetry::KeyValue;
+use portable_atomic::{AtomicF64, Ordering};
+use std::sync::atomic::AtomicU64;
+use std::sync::Arc;
+
+pub struct OtelCounter {
+    #[allow(dead_code)] // prevent from drop
+    counter: ObservableCounter<u64>,
+    value: Arc<AtomicU64>,
+}
+
+impl OtelCounter {
+    pub fn new(
+        counter_builder: AsyncInstrumentBuilder<ObservableCounter<u64>, u64>,
+        attributes: Vec<KeyValue>,
+    ) -> Self {
+        let value = Arc::new(AtomicU64::new(0));
+        let value_moved = Arc::clone(&value);
+        let otel_counter = counter_builder
+            .with_callback(move |observer| {
+                observer.observe(value_moved.load(Ordering::Relaxed), &attributes);
+            })
+            .build();
+        Self { counter: otel_counter, value }
+    }
+}
+
+impl CounterFn for OtelCounter {
+    fn increment(&self, value: u64) {
+        self.value.fetch_add(value, Ordering::Relaxed);
+    }
+
+    fn absolute(&self, value: u64) {
+        self.value.store(value, Ordering::Relaxed);
+    }
+}
+
+pub struct OtelGauge {
+    #[allow(dead_code)] // prevent from drop
+    gauge: ObservableGauge<f64>,
+    value: Arc<AtomicF64>,
+}
+
+impl OtelGauge {
+    pub fn new(
+        gauge_builder: AsyncInstrumentBuilder<ObservableGauge<f64>, f64>,
+        attributes: Vec<KeyValue>,
+    ) -> Self {
+        let value = Arc::new(AtomicF64::new(0.0));
+        let value_moved = value.clone();
+        let otel_gauge = gauge_builder
+            .with_callback(move |observer| {
+                observer.observe(value_moved.load(Ordering::Relaxed), &attributes);
+            })
+            .build();
+        Self { gauge: otel_gauge, value }
+    }
+}
+
+impl GaugeFn for OtelGauge {
+    fn increment(&self, value: f64) {
+        self.value.fetch_add(value, Ordering::Relaxed);
+    }
+
+    fn decrement(&self, value: f64) {
+        self.value.fetch_sub(value, Ordering::Relaxed);
+    }
+
+    fn set(&self, value: f64) {
+        self.value.store(value, Ordering::Relaxed);
+    }
+}
+
+pub struct OtelHistogram {
+    histogram: Histogram<f64>,
+    attributes: Vec<KeyValue>,
+}
+
+impl OtelHistogram {
+    pub fn new(histogram: Histogram<f64>, attributes: Vec<KeyValue>) -> Self {
+        Self { histogram, attributes }
+    }
+}
+
+impl HistogramFn for OtelHistogram {
+    fn record(&self, value: f64) {
+        self.histogram.record(value, &self.attributes);
+    }
+}

metrics-exporter-opentelemetry/src/instruments.rs

@@ -0,0 +1,60 @@
+//! An OpenTelemetry metrics exporter for `metrics`.
+mod instruments;
+mod storage;
+
+use metrics::{Counter, Gauge, Histogram, Key, KeyName, Recorder, SharedString, Unit};
+use metrics_util::registry::{Registry, Storage};
+use opentelemetry::metrics::Meter;
+use crate::storage::OtelMetricStorage;
+
+/// The OpenTelemetry recorder.
+pub struct OpenTelemetryRecorder {
+    registry: Registry<Key, OtelMetricStorage>,
+}
+
+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),
+        }
+    }
+}
+
+impl Recorder for OpenTelemetryRecorder {
+    fn describe_counter(&self, _key_name: KeyName, _unit: Option<Unit>, _description: SharedString) {
+        // Descriptions are handled when creating instruments
+    }
+
+    fn describe_gauge(&self, _key_name: KeyName, _unit: Option<Unit>, _description: SharedString) {
+        // Descriptions are handled when creating instruments
+    }
+
+    fn describe_histogram(
+        &self,
+        _key_name: KeyName,
+        _unit: Option<Unit>,
+        _description: SharedString,
+    ) {
+        // Descriptions are handled when creating instruments
+    }
+
+    fn register_counter(&self, key: &Key, _metadata: &metrics::Metadata<'_>) -> Counter {
+        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())
+        })
+    }
+
+    fn register_histogram(&self, key: &Key, _metadata: &metrics::Metadata<'_>) -> Histogram {
+        self.registry.get_or_create_histogram(key, |h| {
+            Histogram::from_arc(h.clone())
+        })
+    }
+}

metrics-exporter-opentelemetry/src/lib.rs

@@ -0,0 +1,54 @@
+use std::sync::Arc;
+use opentelemetry::KeyValue;
+use opentelemetry::metrics::Meter;
+use metrics::Key;
+use metrics_util::registry::Storage;
+use crate::instruments::{OtelCounter, OtelGauge, OtelHistogram};
+
+pub struct OtelMetricStorage {
+    meter: Meter,
+}
+
+impl OtelMetricStorage {
+    pub fn new(meter: Meter) -> Self {
+        Self { meter }
+    }
+
+    fn get_attributes(key: &Key) -> Vec<KeyValue> {
+        key.labels()
+            .map(|label| KeyValue::new(label.key().to_string(), label.value().to_string()))
+            .collect()
+    }
+}
+
+impl Storage<Key> for OtelMetricStorage {
+    type Counter = Arc<OtelCounter>;
+    type Gauge = Arc<OtelGauge>;
+    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 attributes = Self::get_attributes(key);
+        Arc::new(OtelCounter::new(otel_counter_builder, attributes))
+    }
+
+    fn gauge(&self, key: &Key) -> Self::Gauge {
+        let builder = self
+            .meter
+            .f64_observable_gauge(key.name().to_string());
+        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 attributes = Self::get_attributes(key);
+        Arc::new(OtelHistogram::new(histogram, attributes))
+
+    }
+}