Removed Clone on metric data

Author: fraillt

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

@@ -9,7 +9,7 @@ use crate::Resource;
 use super::Temporality;
 
 /// A collection of [ScopeMetrics] and the associated [Resource] that created them.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ResourceMetrics {
     /// The entity that collected the metrics.
     pub resource: Resource,
@@ -18,7 +18,7 @@ pub struct ResourceMetrics {
 }
 
 /// A collection of metrics produced by a meter.
-#[derive(Default, Clone, Debug)]
+#[derive(Default, Debug)]
 pub struct ScopeMetrics {
     /// The [InstrumentationScope] that the meter was created with.
     pub scope: InstrumentationScope,
@@ -29,7 +29,7 @@ pub struct ScopeMetrics {
 /// A collection of one or more aggregated time series from an [Instrument].
 ///
 /// [Instrument]: crate::metrics::Instrument
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct Metric {
     /// The name of the instrument that created this data.
     pub name: Cow<'static, str>,
@@ -42,7 +42,7 @@ pub struct Metric {
 }
 
 /// Aggregated metrics data from an instrument
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum AggregatedMetrics {
     /// All metric data with `f64` value type
     F64(MetricData<f64>),
@@ -53,7 +53,7 @@ pub enum AggregatedMetrics {
 }
 
 /// Metric data for all types
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum MetricData<T> {
     /// Metric data for Gauge
     Gauge(Gauge<T>),

opentelemetry-sdk/src/metrics/in_memory_exporter.rs

@@ -1,12 +1,16 @@
 use crate::error::{OTelSdkError, OTelSdkResult};
-use crate::metrics::data::ResourceMetrics;
+use crate::metrics::data::{
+    ExponentialHistogram, Gauge, Histogram, MetricData, ResourceMetrics, Sum,
+};
 use crate::metrics::exporter::PushMetricExporter;
 use crate::metrics::Temporality;
 use crate::InMemoryExporterError;
 use std::collections::VecDeque;
 use std::fmt;
 use std::sync::{Arc, Mutex};
 
+use super::data::{AggregatedMetrics, Metric, ScopeMetrics};
+
 /// An in-memory metrics exporter that stores metrics data in memory.
 ///
 /// This exporter is useful for testing and debugging purposes. It stores
@@ -145,7 +149,7 @@ impl InMemoryMetricExporter {
         let metrics = self
             .metrics
             .lock()
-            .map(|metrics_guard| metrics_guard.iter().cloned().collect())
+            .map(|metrics_guard| metrics_guard.iter().map(Self::clone_metrics).collect())
             .map_err(InMemoryExporterError::from)?;
         Ok(metrics)
     }
@@ -166,13 +170,78 @@ impl InMemoryMetricExporter {
             .lock()
             .map(|mut metrics_guard| metrics_guard.clear());
     }
+
+    fn clone_metrics(metric: &ResourceMetrics) -> ResourceMetrics {
+        ResourceMetrics {
+            resource: metric.resource.clone(),
+            scope_metrics: metric
+                .scope_metrics
+                .iter()
+                .map(|scope_metric| ScopeMetrics {
+                    scope: scope_metric.scope.clone(),
+                    metrics: scope_metric
+                        .metrics
+                        .iter()
+                        .map(|metric| Metric {
+                            name: metric.name.clone(),
+                            description: metric.description.clone(),
+                            unit: metric.unit.clone(),
+                            data: Self::clone_data(&metric.data),
+                        })
+                        .collect(),
+                })
+                .collect(),
+        }
+    }
+
+    fn clone_data(data: &AggregatedMetrics) -> AggregatedMetrics {
+        fn clone_inner<T: Clone>(data: &MetricData<T>) -> MetricData<T> {
+            match data {
+                MetricData::Gauge(gauge) => Gauge {
+                    data_points: gauge.data_points.clone(),
+                    start_time: gauge.start_time,
+                    time: gauge.time,
+                }
+                .into(),
+                MetricData::Sum(sum) => Sum {
+                    data_points: sum.data_points.clone(),
+                    start_time: sum.start_time,
+                    time: sum.time,
+                    temporality: sum.temporality,
+                    is_monotonic: sum.is_monotonic,
+                }
+                .into(),
+                MetricData::Histogram(histogram) => Histogram {
+                    data_points: histogram.data_points.clone(),
+                    start_time: histogram.start_time,
+                    time: histogram.time,
+                    temporality: histogram.temporality,
+                }
+                .into(),
+                MetricData::ExponentialHistogram(exponential_histogram) => ExponentialHistogram {
+                    data_points: exponential_histogram.data_points.clone(),
+                    start_time: exponential_histogram.start_time,
+                    time: exponential_histogram.time,
+                    temporality: exponential_histogram.temporality,
+                }
+                .into(),
+            }
+        }
+        match data {
+            AggregatedMetrics::F64(metric_data) => AggregatedMetrics::F64(clone_inner(metric_data)),
+            AggregatedMetrics::U64(metric_data) => AggregatedMetrics::U64(clone_inner(metric_data)),
+            AggregatedMetrics::I64(metric_data) => AggregatedMetrics::I64(clone_inner(metric_data)),
+        }
+    }
 }
 
 impl PushMetricExporter for InMemoryMetricExporter {
     async fn export(&self, metrics: &mut ResourceMetrics) -> OTelSdkResult {
         self.metrics
             .lock()
-            .map(|mut metrics_guard| metrics_guard.push_back(metrics.clone()))
+            .map(|mut metrics_guard| {
+                metrics_guard.push_back(InMemoryMetricExporter::clone_metrics(metrics))
+            })
             .map_err(|_| OTelSdkError::InternalFailure("Failed to lock metrics".to_string()))
     }