* Renamed ResourceMetric->ResourceMetricData and moved to

MetricReader.
* Renamed ResourceMetricRef->ResourceMetric and made that
iteration would borrow an item, which will allow improving
underlying metric collection without any allocations in the future
* Updated CHANGELOG.md

Author: fraillt

opentelemetry-otlp/src/exporter/http/metrics.rs

@@ -4,12 +4,12 @@ use crate::metric::MetricsClient;
 use http::{header::CONTENT_TYPE, Method};
 use opentelemetry::otel_debug;
 use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult};
-use opentelemetry_sdk::metrics::exporter::ResourceMetricsRef;
+use opentelemetry_sdk::metrics::exporter::ResourceMetrics;
 
 use super::OtlpHttpClient;
 
 impl MetricsClient for OtlpHttpClient {
-    async fn export(&self, metrics: ResourceMetricsRef<'_>) -> OTelSdkResult {
+    async fn export(&self, metrics: ResourceMetrics<'_>) -> OTelSdkResult {
         let client = self
             .client
             .lock()

opentelemetry-otlp/src/exporter/http/mod.rs

@@ -27,7 +27,7 @@ use std::time::Duration;
 mod metrics;
 
 #[cfg(feature = "metrics")]
-use opentelemetry_sdk::metrics::exporter::ResourceMetricsRef;
+use opentelemetry_sdk::metrics::exporter::ResourceMetrics;
 
 #[cfg(feature = "logs")]
 pub(crate) mod logs;
@@ -326,7 +326,7 @@ impl OtlpHttpClient {
     #[cfg(feature = "metrics")]
     fn build_metrics_export_body(
         &self,
-        metrics: ResourceMetricsRef<'_>,
+        metrics: ResourceMetrics<'_>,
     ) -> Option<(Vec<u8>, &'static str)> {
         use opentelemetry_proto::tonic::collector::metrics::v1::ExportMetricsServiceRequest;
 

opentelemetry-otlp/src/exporter/tonic/metrics.rs

@@ -6,7 +6,7 @@ use opentelemetry_proto::tonic::collector::metrics::v1::{
     metrics_service_client::MetricsServiceClient, ExportMetricsServiceRequest,
 };
 use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult};
-use opentelemetry_sdk::metrics::exporter::ResourceMetricsRef;
+use opentelemetry_sdk::metrics::exporter::ResourceMetrics;
 use tonic::{codegen::CompressionEncoding, service::Interceptor, transport::Channel, Request};
 
 use super::BoxInterceptor;
@@ -52,7 +52,7 @@ impl TonicMetricsClient {
 }
 
 impl MetricsClient for TonicMetricsClient {
-    async fn export(&self, metrics: ResourceMetricsRef<'_>) -> OTelSdkResult {
+    async fn export(&self, metrics: ResourceMetrics<'_>) -> OTelSdkResult {
         let (mut client, metadata, extensions) = self
             .inner
             .lock()

opentelemetry-otlp/src/metric.rs

@@ -17,7 +17,7 @@ use crate::{ExporterBuildError, NoExporterBuilderSet};
 use core::fmt;
 use opentelemetry_sdk::error::OTelSdkResult;
 
-use opentelemetry_sdk::metrics::exporter::ResourceMetricsRef;
+use opentelemetry_sdk::metrics::exporter::ResourceMetrics;
 use opentelemetry_sdk::metrics::{exporter::PushMetricExporter, Temporality};
 use std::fmt::{Debug, Formatter};
 use std::time::Duration;
@@ -122,7 +122,7 @@ impl HasHttpConfig for MetricExporterBuilder<HttpExporterBuilderSet> {
 pub(crate) trait MetricsClient: fmt::Debug + Send + Sync + 'static {
     fn export(
         &self,
-        metrics: ResourceMetricsRef<'_>,
+        metrics: ResourceMetrics<'_>,
     ) -> impl std::future::Future<Output = OTelSdkResult> + Send;
     fn shutdown(&self) -> OTelSdkResult;
 }
@@ -148,7 +148,7 @@ impl Debug for MetricExporter {
 }
 
 impl PushMetricExporter for MetricExporter {
-    async fn export(&self, metrics: ResourceMetricsRef<'_>) -> OTelSdkResult {
+    async fn export(&self, metrics: ResourceMetrics<'_>) -> OTelSdkResult {
         match &self.client {
             #[cfg(feature = "grpc-tonic")]
             SupportedTransportClient::Tonic(client) => client.export(metrics).await,

opentelemetry-proto/src/transform/metrics.rs

@@ -13,7 +13,7 @@ pub mod tonic {
         ExponentialHistogram as SdkExponentialHistogram, Gauge as SdkGauge,
         Histogram as SdkHistogram, Metric as SdkMetric, MetricData, Sum as SdkSum,
     };
-    use opentelemetry_sdk::metrics::exporter::{ResourceMetricsRef, ScopeMetricsRef};
+    use opentelemetry_sdk::metrics::exporter::{ResourceMetrics, ScopeMetrics};
     use opentelemetry_sdk::metrics::Temporality;
     use opentelemetry_sdk::Resource as SdkResource;
 
@@ -110,12 +110,16 @@ pub mod tonic {
         }
     }
 
-    impl From<ResourceMetricsRef<'_>> for ExportMetricsServiceRequest {
-        fn from(rm: ResourceMetricsRef<'_>) -> Self {
+    impl From<ResourceMetrics<'_>> for ExportMetricsServiceRequest {
+        fn from(mut rm: ResourceMetrics<'_>) -> Self {
+            let mut scope_metrics = Vec::new();
+            while let Some(scope_metric) = rm.scope_metrics.next() {
+                scope_metrics.push(scope_metric.into());
+            }
             ExportMetricsServiceRequest {
                 resource_metrics: vec![TonicResourceMetrics {
                     resource: Some(rm.resource.into()),
-                    scope_metrics: rm.scope_metrics.map(Into::into).collect(),
+                    scope_metrics,
                     schema_url: rm.resource.schema_url().map(Into::into).unwrap_or_default(),
                 }],
             }
@@ -131,11 +135,15 @@ pub mod tonic {
         }
     }
 
-    impl From<ScopeMetricsRef<'_>> for TonicScopeMetrics {
-        fn from(sm: ScopeMetricsRef<'_>) -> Self {
+    impl From<ScopeMetrics<'_>> for TonicScopeMetrics {
+        fn from(mut sm: ScopeMetrics<'_>) -> Self {
+            let mut metrics = Vec::new();
+            while let Some(metric) = sm.metrics.next() {
+                metrics.push(metric.into());
+            }
             TonicScopeMetrics {
                 scope: Some((sm.scope, None).into()),
-                metrics: sm.metrics.map(Into::into).collect(),
+                metrics,
                 schema_url: sm
                     .scope
                     .schema_url()

opentelemetry-sdk/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## vNext
 
+- *Breaking* change for `PushMetricExporter::export` from accepting 
+  `metrics: &mut ResourceMetrics`, to accepting `metrics: ResourceMetrics<'_>`.
+  In addition, `ResourceMetrics` was also changed to allow improving underlying 
+  metric collection without any allocations in the future.
+  [#2921](https://github.com/open-telemetry/opentelemetry-rust/pull/2921)
+- *Breaking* change for `Metric::data` field: From dynamic `Box<dyn Aggregation>` 
+  to new enum `AggregatedMetrics`.
+  [#2857](https://github.com/open-telemetry/opentelemetry-rust/pull/2857)
+
 [#2868](https://github.com/open-telemetry/opentelemetry-rust/pull/2868)
 `SdkLogger`, `SdkTracer` modified to respect telemetry suppression based on
 `Context`. In other words, if the current context has telemetry suppression
@@ -40,6 +49,7 @@ also modified to suppress telemetry before invoking exporters.
   "spec_unstable_metrics_views". This was only required when using Views.
   [2928](https://github.com/open-telemetry/opentelemetry-rust/pull/2928)
 
+
 ## 0.29.0
 
 Released 2025-Mar-21

opentelemetry-sdk/benches/metric.rs

@@ -6,7 +6,7 @@ use opentelemetry::{
 use opentelemetry_sdk::{
     error::OTelSdkResult,
     metrics::{
-        data::ResourceMetrics, new_view, reader::MetricReader, Aggregation, Instrument,
+        data::ResourceMetricsData, new_view, reader::MetricReader, Aggregation, Instrument,
         InstrumentKind, ManualReader, Pipeline, SdkMeterProvider, Stream, Temporality, View,
     },
     Resource,
@@ -23,7 +23,7 @@ impl MetricReader for SharedReader {
         self.0.register_pipeline(pipeline)
     }
 
-    fn collect(&self, rm: &mut ResourceMetrics) -> OTelSdkResult {
+    fn collect(&self, rm: &mut ResourceMetricsData) -> OTelSdkResult {
         self.0.collect(rm)
     }
 
@@ -240,7 +240,7 @@ fn counters(c: &mut Criterion) {
     });
 
     let (rdr, cntr) = bench_counter(None, "cumulative");
-    let mut rm = ResourceMetrics {
+    let mut rm = ResourceMetricsData {
         resource: Resource::builder_empty().build(),
         scope_metrics: Vec::new(),
     };
@@ -337,7 +337,7 @@ fn benchmark_collect_histogram(b: &mut Bencher, n: usize) {
         h.record(1, &[]);
     }
 
-    let mut rm = ResourceMetrics {
+    let mut rm = ResourceMetricsData {
         resource: Resource::builder_empty().build(),
         scope_metrics: Vec::new(),
     };

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

@@ -2,30 +2,10 @@
 
 use std::{borrow::Cow, time::SystemTime};
 
-use opentelemetry::{InstrumentationScope, KeyValue};
-
-use crate::Resource;
+use opentelemetry::KeyValue;
 
 use super::Temporality;
 
-/// A collection of [ScopeMetrics] and the associated [Resource] that created them.
-#[derive(Debug)]
-pub struct ResourceMetrics {
-    /// The entity that collected the metrics.
-    pub resource: Resource,
-    /// The collection of metrics with unique [InstrumentationScope]s.
-    pub scope_metrics: Vec<ScopeMetrics>,
-}
-
-/// A collection of metrics produced by a meter.
-#[derive(Debug, Default)]
-pub struct ScopeMetrics {
-    /// The [InstrumentationScope] that the meter was created with.
-    pub scope: InstrumentationScope,
-    /// The list of aggregations created by the meter.
-    pub metrics: Vec<Metric>,
-}
-
 /// A collection of one or more aggregated time series from an [Instrument].
 ///
 /// [Instrument]: crate::metrics::Instrument

opentelemetry-sdk/src/metrics/exporter.rs

@@ -6,83 +6,84 @@ use crate::{error::OTelSdkResult, Resource};
 use std::{fmt::Debug, slice::Iter, time::Duration};
 
 use super::{
-    data::{Metric, ResourceMetrics, ScopeMetrics},
+    data::Metric,
+    reader::{ResourceMetricsData, ScopeMetricsData},
     Temporality,
 };
 
 /// A collection of [`BatchScopeMetrics`] and the associated [Resource] that created them.
 #[derive(Debug)]
-pub struct ResourceMetricsRef<'a> {
+pub struct ResourceMetrics<'a> {
     /// The entity that collected the metrics.
     pub resource: &'a Resource,
     /// The collection of metrics with unique [InstrumentationScope]s.
-    pub scope_metrics: BatchScopeMetrics<'a>,
+    pub scope_metrics: ScopeMetricsLendingIter<'a>,
 }
 
 /// Iterator over libraries instrumentation scopes ([`InstrumentationScope`]) together with metrics.
-pub struct BatchScopeMetrics<'a> {
-    iter: Iter<'a, ScopeMetrics>,
+/// Doesn't implement standard [`Iterator`], because it returns borrowed items. AKA "LendingIterator".
+pub struct ScopeMetricsLendingIter<'a> {
+    iter: Iter<'a, ScopeMetricsData>,
 }
 
 /// A collection of metrics produced by a [`InstrumentationScope`] meter.
 #[derive(Debug)]
-pub struct ScopeMetricsRef<'a> {
+pub struct ScopeMetrics<'a> {
     /// The [InstrumentationScope] that the meter was created with.
     pub scope: &'a InstrumentationScope,
     /// The list of aggregations created by the meter.
-    pub metrics: BatchMetrics<'a>,
+    pub metrics: MetricsLendingIter<'a>,
 }
 
 /// Iterator over aggregations created by the meter.
-pub struct BatchMetrics<'a> {
+/// Doesn't implement standard [`Iterator`], because it returns borrowed items. AKA "LendingIterator".
+pub struct MetricsLendingIter<'a> {
     iter: Iter<'a, Metric>,
 }
 
-impl<'a> ResourceMetricsRef<'a> {
-    pub(crate) fn new(rm: &'a ResourceMetrics) -> Self {
+impl<'a> ResourceMetrics<'a> {
+    pub(crate) fn new(rm: &'a ResourceMetricsData) -> Self {
         Self {
             resource: &rm.resource,
-            scope_metrics: BatchScopeMetrics {
+            scope_metrics: ScopeMetricsLendingIter {
                 iter: rm.scope_metrics.iter(),
             },
         }
     }
 }
 
-impl<'a> ScopeMetricsRef<'a> {
-    fn new(sm: &'a ScopeMetrics) -> Self {
+impl<'a> ScopeMetrics<'a> {
+    fn new(sm: &'a ScopeMetricsData) -> Self {
         Self {
             scope: &sm.scope,
-            metrics: BatchMetrics {
+            metrics: MetricsLendingIter {
                 iter: sm.metrics.iter(),
             },
         }
     }
 }
 
-impl Debug for BatchScopeMetrics<'_> {
+impl Debug for ScopeMetricsLendingIter<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("BatchScopeMetrics").finish()
     }
 }
 
-impl<'a> Iterator for BatchScopeMetrics<'a> {
-    type Item = ScopeMetricsRef<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next().map(ScopeMetricsRef::new)
+impl ScopeMetricsLendingIter<'_> {
+    /// Advances the iterator and returns the next value.
+    pub fn next(&mut self) -> Option<ScopeMetrics<'_>> {
+        self.iter.next().map(ScopeMetrics::new)
     }
 }
 
-impl<'a> Iterator for BatchMetrics<'a> {
-    type Item = &'a Metric;
-
-    fn next(&mut self) -> Option<Self::Item> {
+impl MetricsLendingIter<'_> {
+    /// Advances the iterator and returns the next value.
+    pub fn next(&mut self) -> Option<&Metric> {
         self.iter.next()
     }
 }
 
-impl Debug for BatchMetrics<'_> {
+impl Debug for MetricsLendingIter<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("BatchMetrics").finish()
     }
@@ -99,7 +100,7 @@ pub trait PushMetricExporter: Send + Sync + 'static {
     /// considered unrecoverable and will be logged.
     fn export(
         &self,
-        metrics: ResourceMetricsRef<'_>,
+        metrics: ResourceMetrics<'_>,
     ) -> impl std::future::Future<Output = OTelSdkResult> + Send;
 
     /// Flushes any metric data held by an exporter.