Make Metric borrowable

Author: fraillt

opentelemetry-proto/src/transform/metrics.rs

@@ -11,9 +11,9 @@ pub mod tonic {
     use opentelemetry_sdk::metrics::data::{
         AggregatedMetrics, Exemplar as SdkExemplar,
         ExponentialHistogram as SdkExponentialHistogram, Gauge as SdkGauge,
-        Histogram as SdkHistogram, Metric as SdkMetric, MetricData, Sum as SdkSum,
+        Histogram as SdkHistogram, MetricData, Sum as SdkSum,
     };
-    use opentelemetry_sdk::metrics::exporter::{ResourceMetrics, ScopeMetrics};
+    use opentelemetry_sdk::metrics::exporter::{Metric, ResourceMetrics, ScopeMetrics};
     use opentelemetry_sdk::metrics::Temporality;
     use opentelemetry_sdk::Resource as SdkResource;
 
@@ -153,12 +153,12 @@ pub mod tonic {
         }
     }
 
-    impl From<&SdkMetric> for TonicMetric {
-        fn from(metric: &SdkMetric) -> Self {
+    impl From<Metric<'_>> for TonicMetric {
+        fn from(metric: Metric<'_>) -> Self {
             TonicMetric {
-                name: metric.name.to_string(),
-                description: metric.description.to_string(),
-                unit: metric.unit.to_string(),
+                name: metric.instrument.name.to_string(),
+                description: metric.instrument.description.to_string(),
+                unit: metric.instrument.unit.to_string(),
                 metadata: vec![], // internal and currently unused
                 data: Some(match &metric.data {
                     AggregatedMetrics::F64(data) => data.into(),

opentelemetry-sdk/src/metrics/data/mod.rs

@@ -1,26 +1,11 @@
 //! Types for delivery of pre-aggregated metric time series data.
 
-use std::{borrow::Cow, time::SystemTime};
+use std::time::SystemTime;
 
 use opentelemetry::KeyValue;
 
 use super::Temporality;
 
-/// A collection of one or more aggregated time series from an [Instrument].
-///
-/// [Instrument]: crate::metrics::Instrument
-#[derive(Debug)]
-pub struct Metric {
-    /// The name of the instrument that created this data.
-    pub name: Cow<'static, str>,
-    /// The description of the instrument, which can be used in documentation.
-    pub description: Cow<'static, str>,
-    /// The unit in which the instrument reports.
-    pub unit: Cow<'static, str>,
-    /// The aggregated data from an instrument.
-    pub data: AggregatedMetrics,
-}
-
 /// Aggregated metrics data from an instrument
 #[derive(Debug)]
 pub enum AggregatedMetrics {

opentelemetry-sdk/src/metrics/exporter.rs

@@ -6,9 +6,9 @@ use crate::{error::OTelSdkResult, Resource};
 use std::{fmt::Debug, slice::Iter, time::Duration};
 
 use super::{
-    data::Metric,
-    reader::{ResourceMetricsData, ScopeMetricsData},
-    Temporality,
+    data::AggregatedMetrics,
+    reader::{MetricsData, ResourceMetricsData, ScopeMetricsData},
+    InstrumentInfo, Temporality,
 };
 
 /// A collection of [`BatchScopeMetrics`] and the associated [Resource] that created them.
@@ -38,7 +38,18 @@ pub struct ScopeMetrics<'a> {
 /// Iterator over aggregations created by the meter.
 /// Doesn't implement standard [`Iterator`], because it returns borrowed items. AKA "LendingIterator".
 pub struct MetricsLendingIter<'a> {
-    iter: Iter<'a, Metric>,
+    iter: Iter<'a, MetricsData>,
+}
+
+/// A collection of one or more aggregated time series from an [Instrument].
+///
+/// [Instrument]: crate::metrics::Instrument
+#[derive(Debug)]
+pub struct Metric<'a> {
+    /// The name of the instrument that created this data.
+    pub instrument: &'a InstrumentInfo,
+    /// The aggregated data from an instrument.
+    pub data: &'a AggregatedMetrics,
 }
 
 impl<'a> ResourceMetrics<'a> {
@@ -78,8 +89,11 @@ impl ScopeMetricsLendingIter<'_> {
 
 impl MetricsLendingIter<'_> {
     /// Advances the iterator and returns the next value.
-    pub fn next(&mut self) -> Option<&Metric> {
-        self.iter.next()
+    pub fn next(&mut self) -> Option<Metric<'_>> {
+        self.iter.next().map(|metric| Metric {
+            instrument: &metric.instrument,
+            data: &metric.data,
+        })
     }
 }
 

opentelemetry-sdk/src/metrics/in_memory_exporter.rs

@@ -8,9 +8,9 @@ use std::fmt;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use super::data::{AggregatedMetrics, Metric};
+use super::data::AggregatedMetrics;
 use super::exporter::ResourceMetrics;
-use super::reader::{ResourceMetricsData, ScopeMetricsData};
+use super::reader::{MetricsData, ResourceMetricsData, ScopeMetricsData};
 
 /// An in-memory metrics exporter that stores metrics data in memory.
 ///
@@ -163,10 +163,8 @@ impl InMemoryMetricExporter {
                                 metrics: data
                                     .metrics
                                     .iter()
-                                    .map(|data| Metric {
-                                        name: data.name.clone(),
-                                        description: data.description.clone(),
-                                        unit: data.unit.clone(),
+                                    .map(|data| MetricsData {
+                                        instrument: data.instrument.clone(),
                                         data: Self::clone_data(&data.data),
                                     })
                                     .collect(),
@@ -201,10 +199,8 @@ impl InMemoryMetricExporter {
         while let Some(mut scope_metric) = metric.scope_metrics.next() {
             let mut metrics = Vec::new();
             while let Some(metric) = scope_metric.metrics.next() {
-                metrics.push(Metric {
-                    name: metric.name.clone(),
-                    description: metric.description.clone(),
-                    unit: metric.unit.clone(),
+                metrics.push(MetricsData {
+                    instrument: metric.instrument.clone(),
                     data: Self::clone_data(&metric.data),
                 });
             }

opentelemetry-sdk/src/metrics/instrument.rs

@@ -65,6 +65,19 @@ impl InstrumentKind {
     }
 }
 
+/// Describes properties an instrument is created with
+#[derive(Debug, Clone)]
+pub struct InstrumentInfo {
+    /// The human-readable identifier of the instrument.
+    pub name: Cow<'static, str>,
+    /// describes the purpose of the instrument.
+    pub description: Cow<'static, str>,
+    /// The functional group of the instrument.
+    pub kind: InstrumentKind,
+    /// Unit is the unit of measurement recorded by the instrument.
+    pub unit: Cow<'static, str>,
+}
+
 /// Describes properties an instrument is created with, also used for filtering
 /// in [View](crate::metrics::View)s.
 ///

opentelemetry-sdk/src/metrics/mod.rs

@@ -690,8 +690,8 @@ mod tests {
             "There should be single metric merging duplicate instruments"
         );
         let metric = &resource_metrics[0].scope_metrics[0].metrics[0];
-        assert_eq!(metric.name, "my_counter");
-        assert_eq!(metric.unit, "my_unit");
+        assert_eq!(metric.instrument.name, "my_counter");
+        assert_eq!(metric.instrument.unit, "my_unit");
         let MetricData::Sum(sum) = u64::extract_metrics_data_ref(&metric.data)
             .expect("Sum aggregation expected for Counter instruments by default")
         else {
@@ -756,9 +756,9 @@ mod tests {
 
         if let Some(scope1) = scope1 {
             let metric1 = &scope1.metrics[0];
-            assert_eq!(metric1.name, "my_counter");
-            assert_eq!(metric1.unit, "my_unit");
-            assert_eq!(metric1.description, "my_description");
+            assert_eq!(metric1.instrument.name, "my_counter");
+            assert_eq!(metric1.instrument.unit, "my_unit");
+            assert_eq!(metric1.instrument.description, "my_description");
             let MetricData::Sum(sum1) = u64::extract_metrics_data_ref(&metric1.data)
                 .expect("Sum aggregation expected for Counter instruments by default")
             else {
@@ -776,9 +776,9 @@ mod tests {
 
         if let Some(scope2) = scope2 {
             let metric2 = &scope2.metrics[0];
-            assert_eq!(metric2.name, "my_counter");
-            assert_eq!(metric2.unit, "my_unit");
-            assert_eq!(metric2.description, "my_description");
+            assert_eq!(metric2.instrument.name, "my_counter");
+            assert_eq!(metric2.instrument.unit, "my_unit");
+            assert_eq!(metric2.instrument.description, "my_description");
 
             let MetricData::Sum(sum2) = u64::extract_metrics_data_ref(&metric2.data)
                 .expect("Sum aggregation expected for Counter instruments by default")
@@ -862,9 +862,9 @@ mod tests {
         assert!(scope.attributes().eq(&[KeyValue::new("key", "value1")]));
 
         let metric = &resource_metrics[0].scope_metrics[0].metrics[0];
-        assert_eq!(metric.name, "my_counter");
-        assert_eq!(metric.unit, "my_unit");
-        assert_eq!(metric.description, "my_description");
+        assert_eq!(metric.instrument.name, "my_counter");
+        assert_eq!(metric.instrument.unit, "my_unit");
+        assert_eq!(metric.instrument.description, "my_description");
 
         let MetricData::Sum(sum) = u64::extract_metrics_data_ref(&metric.data)
             .expect("Sum aggregation expected for Counter instruments by default")
@@ -919,11 +919,11 @@ mod tests {
         assert!(!resource_metrics.is_empty());
         let metric = &resource_metrics[0].scope_metrics[0].metrics[0];
         assert_eq!(
-            metric.name, "test_histogram",
+            metric.instrument.name, "test_histogram",
             "View rename should be ignored and original name retained."
         );
         assert_eq!(
-            metric.unit, "test_unit",
+            metric.instrument.unit, "test_unit",
             "View rename of unit should be ignored and original unit retained."
         );
     }
@@ -985,7 +985,7 @@ mod tests {
             .expect("metrics are expected to be exported.");
         assert!(!resource_metrics.is_empty());
         let metric = &resource_metrics[0].scope_metrics[0].metrics[0];
-        assert_eq!(metric.name, "my_observable_counter",);
+        assert_eq!(metric.instrument.name, "my_observable_counter",);
 
         let MetricData::Sum(sum) = u64::extract_metrics_data_ref(&metric.data)
             .expect("Sum aggregation expected for ObservableCounter instruments by default")
@@ -1061,7 +1061,7 @@ mod tests {
             .expect("metrics are expected to be exported.");
         assert!(!resource_metrics.is_empty());
         let metric = &resource_metrics[0].scope_metrics[0].metrics[0];
-        assert_eq!(metric.name, "my_counter",);
+        assert_eq!(metric.instrument.name, "my_counter",);
 
         let MetricData::Sum(sum) = u64::extract_metrics_data_ref(&metric.data)
             .expect("Sum aggregation expected for Counter instruments by default")
@@ -3029,9 +3029,9 @@ mod tests {
             assert!(!resource_metric.scope_metrics[0].metrics.is_empty());
 
             let metric = &resource_metric.scope_metrics[0].metrics[0];
-            assert_eq!(metric.name, counter_name);
+            assert_eq!(metric.instrument.name, counter_name);
             if let Some(expected_unit) = unit_name {
-                assert_eq!(metric.unit, expected_unit);
+                assert_eq!(metric.instrument.unit, expected_unit);
             }
 
             T::extract_metrics_data_ref(&metric.data)
@@ -3073,10 +3073,10 @@ mod tests {
                     assert!(!resource_metric.scope_metrics[0].metrics.is_empty());
 
                     let metric = &resource_metric.scope_metrics[0].metrics[0];
-                    assert_eq!(metric.name, counter_name);
+                    assert_eq!(metric.instrument.name, counter_name);
 
                     if let Some(expected_unit) = unit_name {
-                        assert_eq!(metric.unit, expected_unit);
+                        assert_eq!(metric.instrument.unit, expected_unit);
                     }
 
                     let aggregation = T::extract_metrics_data_ref(&metric.data)

opentelemetry-sdk/src/metrics/pipeline.rs

@@ -11,12 +11,11 @@ use crate::{
     error::{OTelSdkError, OTelSdkResult},
     metrics::{
         aggregation,
-        data::Metric,
         error::{MetricError, MetricResult},
         instrument::{Instrument, InstrumentId, InstrumentKind, Stream},
         internal::{self, AggregateBuilder, Number},
-        reader::{MetricReader, ScopeMetricsData, SdkProducer},
-        view::View,
+        reader::{MetricReader, MetricsData, ScopeMetricsData, SdkProducer},
+        view::View, InstrumentInfo,
     },
     Resource,
 };
@@ -138,10 +137,8 @@ impl SdkProducer for Pipeline {
                 let mut m = sm.metrics.get_mut(j);
                 match (inst.comp_agg.call(m.as_mut().map(|m| &mut m.data)), m) {
                     // No metric to re-use, expect agg to create new metric data
-                    ((len, Some(initial_agg)), None) if len > 0 => sm.metrics.push(Metric {
-                        name: inst.name.clone(),
-                        description: inst.description.clone(),
-                        unit: inst.unit.clone(),
+                    ((len, Some(initial_agg)), None) if len > 0 => sm.metrics.push(MetricsData {
+                        instrument: inst.info.clone(),
                         data: initial_agg,
                     }),
                     // Existing metric can be re-used, update its values
@@ -150,9 +147,7 @@ impl SdkProducer for Pipeline {
                             // previous aggregation was of a different type
                             prev_agg.data = data;
                         }
-                        prev_agg.name.clone_from(&inst.name);
-                        prev_agg.description.clone_from(&inst.description);
-                        prev_agg.unit.clone_from(&inst.unit);
+                        prev_agg.instrument.clone_from(&inst.info);
                     }
                     _ => continue,
                 }
@@ -175,18 +170,16 @@ impl SdkProducer for Pipeline {
 
 /// A synchronization point between a [Pipeline] and an instrument's aggregate function.
 struct InstrumentSync {
-    name: Cow<'static, str>,
-    description: Cow<'static, str>,
-    unit: Cow<'static, str>,
+    info: InstrumentInfo,
     comp_agg: Arc<dyn internal::ComputeAggregation>,
 }
 
 impl fmt::Debug for InstrumentSync {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("InstrumentSync")
-            .field("name", &self.name)
-            .field("description", &self.description)
-            .field("unit", &self.unit)
+            .field("name", &self.info.name)
+            .field("description", &self.info.description)
+            .field("unit", &self.info.unit)
             .finish()
     }
 }
@@ -410,9 +403,12 @@ where
             self.pipeline.add_sync(
                 scope.clone(),
                 InstrumentSync {
-                    name: stream.name,
-                    description: stream.description,
-                    unit: stream.unit,
+                    info: InstrumentInfo {
+                        name: stream.name,
+                        description: stream.description,
+                        unit: stream.unit,
+                        kind,
+                    },
                     comp_agg: collect,
                 },
             );

opentelemetry-sdk/src/metrics/reader.rs

@@ -6,7 +6,8 @@ use crate::Resource;
 use std::time::Duration;
 use std::{fmt, sync::Weak};
 
-use super::data::Metric;
+use super::data::AggregatedMetrics;
+use super::InstrumentInfo;
 use super::{pipeline::Pipeline, InstrumentKind, Temporality};
 
 /// A collection of [ScopeMetricsData] and the associated [Resource] that created them.
@@ -24,7 +25,18 @@ pub struct ScopeMetricsData {
     /// The [InstrumentationScope] that the meter was created with.
     pub scope: InstrumentationScope,
     /// The list of aggregations created by the meter.
-    pub metrics: Vec<Metric>,
+    pub metrics: Vec<MetricsData>,
+}
+
+/// A collection of one or more aggregated time series from an [Instrument].
+///
+/// [Instrument]: crate::metrics::Instrument
+#[derive(Debug)]
+pub struct MetricsData {
+    /// The name of the instrument that created this data.
+    pub instrument: InstrumentInfo,
+    /// The aggregated data from an instrument.
+    pub data: AggregatedMetrics,
 }
 
 /// The interface used between the SDK and an exporter.

opentelemetry-stdout/src/metrics/exporter.rs

@@ -111,9 +111,9 @@ fn print_metrics(mut metrics: MetricsLendingIter<'_>) {
         iter += 1;
 
         println!("Metric #{}", iter);
-        println!("\t\tName         : {}", &metric.name);
-        println!("\t\tDescription  : {}", &metric.description);
-        println!("\t\tUnit         : {}", &metric.unit);
+        println!("\t\tName         : {}", &metric.instrument.name);
+        println!("\t\tDescription  : {}", &metric.instrument.description);
+        println!("\t\tUnit         : {}", &metric.instrument.unit);
 
         fn print_info<T>(data: &MetricData<T>)
         where