Upgrade to otel 0.30 (#205)

## Motivation

There were some breaking changes with the upgrade to otel 0.30:
https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-sdk/CHANGELOG.md#0300

I was able to fix upgrade them without much of an issue. The only
compilation issues were in the metrics_publishing test. A few of the
types used in that test now require the
`experimental_metrics_custom_reader` feature to be enabled in the
opentelemetry-sdk package.


## Solution

Bump the versions & fix the one test file that had compilation errors.

Author: BSteffaniak

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Unreleased
 
+### Breaking Changes
+
+- Upgrade from opentelemetry 0.29.0 to 0.30.0. Refer to the upstream
+  [changelog](https://github.com/open-telemetry/opentelemetry-rust/blob/main/opentelemetry-sdk/CHANGELOG.md#0300)
+  for more information.
+
 ### Added
 
 - Add `OpenTelemetrySpanExt::add_event` and `OpenTelemetrySpanExt::add_event_with_timestamp` 

Cargo.toml

@@ -23,8 +23,8 @@ metrics = ["opentelemetry/metrics","opentelemetry_sdk/metrics", "smallvec"]
 metrics_gauge_unstable = []
 
 [dependencies]
-opentelemetry = { version = "0.29.0", default-features = false, features = ["trace"] }
-opentelemetry_sdk = { version = "0.29.0", default-features = false, features = ["trace"] }
+opentelemetry = { version = "0.30.0", default-features = false, features = ["trace"] }
+opentelemetry_sdk = { version = "0.30.0", default-features = false, features = ["trace"] }
 tracing = { version = "0.1.35", default-features = false, features = ["std"] }
 tracing-core = "0.1.28"
 tracing-subscriber = { version = "0.3.0", default-features = false, features = ["registry", "std"] }
@@ -43,11 +43,11 @@ smallvec = { version = "1.0", optional = true }
 [dev-dependencies]
 async-trait = "0.1.56"
 criterion = { version = "0.5.1", default-features = false, features = ["html_reports"] }
-opentelemetry = { version = "0.29.0", features = ["trace", "metrics"] }
-opentelemetry_sdk = { version = "0.29.0", default-features = false, features = ["trace", "rt-tokio"] }
-opentelemetry-stdout = { version = "0.29.0", features = ["trace", "metrics"] }
-opentelemetry-otlp = { version = "0.29.0", features = ["metrics", "grpc-tonic"] }
-opentelemetry-semantic-conventions = { version = "0.29.0", features = ["semconv_experimental"] }
+opentelemetry = { version = "0.30.0", features = ["trace", "metrics"] }
+opentelemetry_sdk = { version = "0.30.0", default-features = false, features = ["trace", "rt-tokio", "experimental_metrics_custom_reader"] }
+opentelemetry-stdout = { version = "0.30.0", features = ["trace", "metrics"] }
+opentelemetry-otlp = { version = "0.30.0", features = ["metrics", "grpc-tonic"] }
+opentelemetry-semantic-conventions = { version = "0.30.0", features = ["semconv_experimental"] }
 futures-util = { version = "0.3.17", default-features = false }
 tokio = { version = "1", features = ["full"] }
 tokio-stream = "0.1"

tests/metrics_publishing.rs

@@ -4,9 +4,8 @@ use opentelemetry_sdk::{
     metrics::{
         data::{self, Gauge, Histogram, Sum},
         reader::MetricReader,
-        InstrumentKind, ManualReader, MeterProviderBuilder, MetricError, SdkMeterProvider,
+        InstrumentKind, ManualReader, MeterProviderBuilder, SdkMeterProvider,
     },
-    Resource,
 };
 
 use std::{fmt::Debug, sync::Arc};
@@ -548,10 +547,7 @@ impl MetricReader for TestReader {
         self.inner.register_pipeline(pipeline);
     }
 
-    fn collect(
-        &self,
-        rm: &mut data::ResourceMetrics,
-    ) -> opentelemetry_sdk::metrics::MetricResult<()> {
+    fn collect(&self, rm: &mut data::ResourceMetrics) -> OTelSdkResult {
         self.inner.collect(rm)
     }
 
@@ -566,6 +562,10 @@ impl MetricReader for TestReader {
     fn temporality(&self, kind: InstrumentKind) -> opentelemetry_sdk::metrics::Temporality {
         self.inner.temporality(kind)
     }
+
+    fn shutdown_with_timeout(&self, timeout: std::time::Duration) -> OTelSdkResult {
+        self.inner.shutdown_with_timeout(timeout)
+    }
 }
 
 struct TestExporter<T> {
@@ -577,78 +577,105 @@ struct TestExporter<T> {
     _meter_provider: SdkMeterProvider,
 }
 
+trait AsAny {
+    fn as_any(&self) -> &dyn std::any::Any;
+}
+
+impl AsAny for data::AggregatedMetrics {
+    fn as_any(&self) -> &dyn std::any::Any {
+        match self {
+            data::AggregatedMetrics::F64(x) => match x {
+                data::MetricData::Gauge(x) => x as &dyn std::any::Any,
+                data::MetricData::Sum(x) => x as &dyn std::any::Any,
+                data::MetricData::Histogram(x) => x as &dyn std::any::Any,
+                data::MetricData::ExponentialHistogram(x) => x as &dyn std::any::Any,
+            },
+            data::AggregatedMetrics::U64(x) => match x {
+                data::MetricData::Gauge(x) => x as &dyn std::any::Any,
+                data::MetricData::Sum(x) => x as &dyn std::any::Any,
+                data::MetricData::Histogram(x) => x as &dyn std::any::Any,
+                data::MetricData::ExponentialHistogram(x) => x as &dyn std::any::Any,
+            },
+            data::AggregatedMetrics::I64(x) => match x {
+                data::MetricData::Gauge(x) => x as &dyn std::any::Any,
+                data::MetricData::Sum(x) => x as &dyn std::any::Any,
+                data::MetricData::Histogram(x) => x as &dyn std::any::Any,
+                data::MetricData::ExponentialHistogram(x) => x as &dyn std::any::Any,
+            },
+        }
+    }
+}
+
 impl<T> TestExporter<T>
 where
     T: Debug + PartialEq + Copy + std::iter::Sum + 'static,
 {
-    fn export(&self) -> Result<(), MetricError> {
-        let mut rm = data::ResourceMetrics {
-            resource: Resource::builder().build(),
-            scope_metrics: Vec::new(),
-        };
+    fn export(&self) -> OTelSdkResult {
+        let mut rm = data::ResourceMetrics::default();
         self.reader.collect(&mut rm)?;
 
-        assert!(!rm.scope_metrics.is_empty());
+        let mut scope_metrics = rm.scope_metrics().peekable();
+
+        assert!(scope_metrics.peek().is_some());
 
-        rm.scope_metrics.into_iter().for_each(|scope_metrics| {
-            assert_eq!(scope_metrics.scope.name(), INSTRUMENTATION_LIBRARY_NAME);
-            assert_eq!(scope_metrics.scope.version().unwrap(), CARGO_PKG_VERSION);
+        scope_metrics.for_each(|scope_metrics| {
+            assert_eq!(scope_metrics.scope().name(), INSTRUMENTATION_LIBRARY_NAME);
+            assert_eq!(scope_metrics.scope().version().unwrap(), CARGO_PKG_VERSION);
 
-            scope_metrics.metrics.into_iter().for_each(|metric| {
-                assert_eq!(metric.name, self.expected_metric_name);
+            scope_metrics.metrics().for_each(|metric| {
+                assert_eq!(metric.name(), self.expected_metric_name);
 
                 match self.expected_instrument_kind {
                     InstrumentKind::Counter | InstrumentKind::UpDownCounter => {
-                        let sum = metric.data.as_any().downcast_ref::<Sum<T>>().unwrap();
+                        let sum = metric.data().as_any().downcast_ref::<Sum<T>>().unwrap();
                         assert_eq!(
                             self.expected_value,
-                            sum.data_points
-                                .iter()
-                                .map(|data_point| data_point.value)
-                                .sum()
+                            sum.data_points().map(|data_point| data_point.value()).sum()
                         );
 
                         if let Some(expected_attributes) = self.expected_attributes.as_ref() {
-                            sum.data_points.iter().for_each(|data_point| {
+                            sum.data_points().for_each(|data_point| {
                                 assert!(compare_attributes(
                                     expected_attributes,
-                                    &data_point.attributes,
+                                    data_point.attributes().cloned().collect(),
                                 ))
                             });
                         }
                     }
                     InstrumentKind::Gauge => {
-                        let gauge = metric.data.as_any().downcast_ref::<Gauge<T>>().unwrap();
+                        let gauge = metric.data().as_any().downcast_ref::<Gauge<T>>().unwrap();
                         assert_eq!(
                             self.expected_value,
                             gauge
-                                .data_points
-                                .iter()
-                                .map(|data_point| data_point.value)
-                                .next_back()
+                                .data_points()
+                                .map(|data_point| data_point.value())
+                                .last()
                                 .unwrap()
                         );
 
                         if let Some(expected_attributes) = self.expected_attributes.as_ref() {
-                            gauge.data_points.iter().for_each(|data_point| {
+                            gauge.data_points().for_each(|data_point| {
                                 assert!(compare_attributes(
                                     expected_attributes,
-                                    &data_point.attributes,
+                                    data_point.attributes().cloned().collect(),
                                 ))
                             });
                         }
                     }
                     InstrumentKind::Histogram => {
-                        let histogram =
-                            metric.data.as_any().downcast_ref::<Histogram<T>>().unwrap();
-                        let histogram_data = histogram.data_points.first().unwrap();
-                        assert!(histogram_data.count > 0);
-                        assert_eq!(histogram_data.sum, self.expected_value);
+                        let histogram = metric
+                            .data()
+                            .as_any()
+                            .downcast_ref::<Histogram<T>>()
+                            .unwrap();
+                        let histogram_data = histogram.data_points().next().unwrap();
+                        assert!(histogram_data.count() > 0);
+                        assert_eq!(histogram_data.sum(), self.expected_value);
 
                         if let Some(expected_attributes) = self.expected_attributes.as_ref() {
                             assert!(compare_attributes(
                                 expected_attributes,
-                                &histogram_data.attributes
+                                histogram_data.attributes().cloned().collect(),
                             ))
                         }
                     }
@@ -666,7 +693,7 @@ where
 // After sorting the KeyValue vec, compare them.
 // Return true if they are equal.
 #[allow(clippy::ptr_arg)]
-fn compare_attributes(expected: &Vec<KeyValue>, actual: &Vec<KeyValue>) -> bool {
+fn compare_attributes(expected: &Vec<KeyValue>, actual: Vec<KeyValue>) -> bool {
     let mut expected = expected.clone();
     let mut actual = actual.clone();