Update opentelemetry to 0.28

Author: cschramm

Cargo.toml

@@ -20,11 +20,11 @@ default = ["tracing-log", "metrics"]
 # Enables support for exporting OpenTelemetry metrics
 metrics = ["opentelemetry/metrics","opentelemetry_sdk/metrics", "smallvec"]
 # Enables experimental support for OpenTelemetry gauge metrics
-metrics_gauge_unstable = ["opentelemetry/otel_unstable"]
+metrics_gauge_unstable = []
 
 [dependencies]
-opentelemetry = { version = "0.27.0", default-features = false, features = ["trace"] }
-opentelemetry_sdk = { version = "0.27.0", default-features = false, features = ["trace"] }
+opentelemetry = { version = "0.28.0", default-features = false, features = ["trace"] }
+opentelemetry_sdk = { version = "0.28.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.27.0", features = ["trace", "metrics"] }
-opentelemetry_sdk = { version = "0.27.0", default-features = false, features = ["trace", "rt-tokio"] }
-opentelemetry-stdout = { version = "0.27.0", features = ["trace", "metrics"] }
-opentelemetry-otlp = { version = "0.27.0", features = ["metrics"] }
-opentelemetry-semantic-conventions = { version = "0.27.0", features = ["semconv_experimental"] }
+opentelemetry = { version = "0.28.0", features = ["trace", "metrics"] }
+opentelemetry_sdk = { version = "0.28.0", default-features = false, features = ["trace", "rt-tokio"] }
+opentelemetry-stdout = { version = "0.28.0", features = ["trace", "metrics"] }
+opentelemetry-otlp = { version = "0.28.0", features = ["metrics", "grpc-tonic"] }
+opentelemetry-semantic-conventions = { version = "0.28.0", features = ["semconv_experimental"] }
 futures-util = { version = "0.3.17", default-features = false }
 tokio = { version = "1", features = ["full"] }
 tokio-stream = "0.1"

benches/trace.rs

@@ -3,7 +3,7 @@ use opentelemetry::{
     trace::{Span, SpanBuilder, Tracer as _, TracerProvider as _},
     Context,
 };
-use opentelemetry_sdk::trace::{Tracer, TracerProvider};
+use opentelemetry_sdk::trace::{SdkTracerProvider, Tracer};
 #[cfg(not(target_os = "windows"))]
 use pprof::criterion::{Output, PProfProfiler};
 use std::time::SystemTime;
@@ -14,7 +14,7 @@ fn many_enters(c: &mut Criterion) {
     let mut group = c.benchmark_group("otel_many_enters");
 
     group.bench_function("spec_baseline", |b| {
-        let provider = TracerProvider::default();
+        let provider = SdkTracerProvider::default();
         let tracer = provider.tracer("bench");
         b.iter(|| {
             fn dummy(tracer: &Tracer, cx: &Context) {
@@ -43,7 +43,7 @@ fn many_enters(c: &mut Criterion) {
     }
 
     {
-        let provider = TracerProvider::default();
+        let provider = SdkTracerProvider::default();
         let tracer = provider.tracer("bench");
         let otel_layer = tracing_opentelemetry::layer()
             .with_tracer(tracer)
@@ -56,7 +56,7 @@ fn many_enters(c: &mut Criterion) {
     }
 
     {
-        let provider = TracerProvider::default();
+        let provider = SdkTracerProvider::default();
         let tracer = provider.tracer("bench");
         let otel_layer = tracing_opentelemetry::layer()
             .with_tracer(tracer)
@@ -73,7 +73,7 @@ fn many_children(c: &mut Criterion) {
     let mut group = c.benchmark_group("otel_many_children");
 
     group.bench_function("spec_baseline", |b| {
-        let provider = TracerProvider::default();
+        let provider = SdkTracerProvider::default();
         let tracer = provider.tracer("bench");
         b.iter(|| {
             fn dummy(tracer: &Tracer, cx: &Context) {
@@ -101,7 +101,7 @@ fn many_children(c: &mut Criterion) {
     }
 
     {
-        let provider = TracerProvider::default();
+        let provider = SdkTracerProvider::default();
         let tracer = provider.tracer("bench");
         let otel_layer = tracing_opentelemetry::layer()
             .with_tracer(tracer)
@@ -118,7 +118,7 @@ fn many_events(c: &mut Criterion) {
     let mut group = c.benchmark_group("otel_many_events");
 
     group.bench_function("spec_baseline", |b| {
-        let provider = TracerProvider::default();
+        let provider = SdkTracerProvider::default();
         let tracer = provider.tracer("bench");
         b.iter(|| {
             fn dummy(tracer: &Tracer, cx: &Context) {
@@ -147,7 +147,7 @@ fn many_events(c: &mut Criterion) {
     }
 
     {
-        let provider = TracerProvider::default();
+        let provider = SdkTracerProvider::default();
         let tracer = provider.tracer("bench");
         let otel_layer = tracing_opentelemetry::layer()
             .with_tracer(tracer)
@@ -160,7 +160,7 @@ fn many_events(c: &mut Criterion) {
     }
 
     {
-        let provider = TracerProvider::builder()
+        let provider = SdkTracerProvider::builder()
             .with_max_events_per_span(1000)
             .build();
         let tracer = provider.tracer("bench");

examples/basic.rs

@@ -1,13 +1,13 @@
 use opentelemetry::trace::TracerProvider as _;
-use opentelemetry_sdk::trace::TracerProvider;
+use opentelemetry_sdk::trace::SdkTracerProvider;
 use opentelemetry_stdout as stdout;
 use tracing::{error, span};
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::Registry;
 
 fn main() {
     // Create a new OpenTelemetry trace pipeline that prints to stdout
-    let provider = TracerProvider::builder()
+    let provider = SdkTracerProvider::builder()
         .with_simple_exporter(stdout::SpanExporter::default())
         .build();
     let tracer = provider.tracer("readme_example");

examples/opentelemetry-error.rs

@@ -8,10 +8,7 @@ use std::{
 
 use opentelemetry::global;
 use opentelemetry::trace::TracerProvider as _;
-use opentelemetry_sdk::{
-    self as sdk,
-    export::trace::{ExportResult, SpanExporter},
-};
+use opentelemetry_sdk::{self as sdk, error::OTelSdkResult, trace::SpanExporter};
 use tracing::{error, instrument, span, trace, warn};
 use tracing_subscriber::prelude::*;
 
@@ -57,11 +54,11 @@ fn double_failable_work(fail: bool) -> Result<&'static str, Error> {
 }
 
 fn main() -> Result<(), Box<dyn StdError + Send + Sync + 'static>> {
-    let builder = sdk::trace::TracerProvider::builder().with_simple_exporter(WriterExporter);
+    let builder = sdk::trace::SdkTracerProvider::builder().with_simple_exporter(WriterExporter);
     let provider = builder.build();
     let tracer = provider.tracer("opentelemetry-write-exporter");
 
-    global::set_tracer_provider(provider);
+    global::set_tracer_provider(provider.clone());
 
     let opentelemetry = tracing_opentelemetry::layer().with_tracer(tracer);
     tracing_subscriber::registry()
@@ -86,7 +83,7 @@ fn main() -> Result<(), Box<dyn StdError + Send + Sync + 'static>> {
     // Shut down the current tracer provider. This will invoke the shutdown
     // method on all span processors. span processors should export remaining
     // spans before return.
-    global::shutdown_tracer_provider();
+    provider.shutdown().unwrap();
 
     Ok(())
 }
@@ -97,19 +94,19 @@ struct WriterExporter;
 impl SpanExporter for WriterExporter {
     fn export(
         &mut self,
-        batch: Vec<sdk::export::trace::SpanData>,
-    ) -> futures_util::future::BoxFuture<'static, sdk::export::trace::ExportResult> {
+        batch: Vec<sdk::trace::SpanData>,
+    ) -> futures_util::future::BoxFuture<'static, OTelSdkResult> {
         let mut writer = std::io::stdout();
         for span in batch {
             writeln!(writer, "{}", SpanData(span)).unwrap();
         }
         writeln!(writer).unwrap();
 
-        Box::pin(async move { ExportResult::Ok(()) })
+        Box::pin(async move { OTelSdkResult::Ok(()) })
     }
 }
 
-struct SpanData(sdk::export::trace::SpanData);
+struct SpanData(sdk::trace::SpanData);
 impl Display for SpanData {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "Span: \"{}\"", self.0.name)?;

examples/opentelemetry-otlp.rs

@@ -1,8 +1,7 @@
 use opentelemetry::{global, trace::TracerProvider as _, KeyValue};
 use opentelemetry_sdk::{
     metrics::{MeterProviderBuilder, PeriodicReader, SdkMeterProvider},
-    runtime,
-    trace::{RandomIdGenerator, Sampler, TracerProvider},
+    trace::{RandomIdGenerator, Sampler, SdkTracerProvider},
     Resource,
 };
 use opentelemetry_semantic_conventions::{
@@ -15,14 +14,16 @@ use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
 // Create a Resource that captures information about the entity for which telemetry is recorded.
 fn resource() -> Resource {
-    Resource::from_schema_url(
-        [
-            KeyValue::new(SERVICE_NAME, env!("CARGO_PKG_NAME")),
-            KeyValue::new(SERVICE_VERSION, env!("CARGO_PKG_VERSION")),
-            KeyValue::new(DEPLOYMENT_ENVIRONMENT_NAME, "develop"),
-        ],
-        SCHEMA_URL,
-    )
+    Resource::builder()
+        .with_schema_url(
+            [
+                KeyValue::new(SERVICE_NAME, env!("CARGO_PKG_NAME")),
+                KeyValue::new(SERVICE_VERSION, env!("CARGO_PKG_VERSION")),
+                KeyValue::new(DEPLOYMENT_ENVIRONMENT_NAME, "develop"),
+            ],
+            SCHEMA_URL,
+        )
+        .build()
 }
 
 // Construct MeterProvider for MetricsLayer
@@ -33,16 +34,13 @@ fn init_meter_provider() -> SdkMeterProvider {
         .build()
         .unwrap();
 
-    let reader = PeriodicReader::builder(exporter, runtime::Tokio)
+    let reader = PeriodicReader::builder(exporter)
         .with_interval(std::time::Duration::from_secs(30))
         .build();
 
     // For debugging in development
-    let stdout_reader = PeriodicReader::builder(
-        opentelemetry_stdout::MetricExporter::default(),
-        runtime::Tokio,
-    )
-    .build();
+    let stdout_reader =
+        PeriodicReader::builder(opentelemetry_stdout::MetricExporter::default()).build();
 
     let meter_provider = MeterProviderBuilder::default()
         .with_resource(resource())
@@ -56,21 +54,21 @@ fn init_meter_provider() -> SdkMeterProvider {
 }
 
 // Construct TracerProvider for OpenTelemetryLayer
-fn init_tracer_provider() -> TracerProvider {
+fn init_tracer_provider() -> SdkTracerProvider {
     let exporter = opentelemetry_otlp::SpanExporter::builder()
         .with_tonic()
         .build()
         .unwrap();
 
-    TracerProvider::builder()
+    SdkTracerProvider::builder()
         // Customize sampling strategy
         .with_sampler(Sampler::ParentBased(Box::new(Sampler::TraceIdRatioBased(
             1.0,
         ))))
         // If export trace to AWS X-Ray, you can use XrayIdGenerator
         .with_id_generator(RandomIdGenerator::default())
         .with_resource(resource())
-        .with_batch_exporter(exporter, runtime::Tokio)
+        .with_batch_exporter(exporter)
         .build()
 }
 
@@ -104,7 +102,7 @@ fn init_tracing_subscriber() -> OtelGuard {
 }
 
 struct OtelGuard {
-    tracer_provider: TracerProvider,
+    tracer_provider: SdkTracerProvider,
     meter_provider: SdkMeterProvider,
 }
 

src/layer.rs

@@ -546,7 +546,7 @@ where
     ///     .build()
     ///     .unwrap();
     ///
-    /// let tracer = opentelemetry_sdk::trace::TracerProvider::builder()
+    /// let tracer = opentelemetry_sdk::trace::SdkTracerProvider::builder()
     ///     .with_simple_exporter(otlp_exporter)
     ///     .build()
     ///     .tracer("trace_demo");
@@ -598,7 +598,7 @@ where
     ///     .build()
     ///     .unwrap();
     ///
-    /// let tracer = opentelemetry_sdk::trace::TracerProvider::builder()
+    /// let tracer = opentelemetry_sdk::trace::SdkTracerProvider::builder()
     ///     .with_simple_exporter(otlp_exporter)
     ///     .build()
     ///     .tracer("trace_demo");

src/lib.rs

@@ -51,14 +51,14 @@
 //! ## Examples
 //!
 //! ```
-//! use opentelemetry_sdk::trace::TracerProvider;
+//! use opentelemetry_sdk::trace::SdkTracerProvider;
 //! use opentelemetry::trace::{Tracer, TracerProvider as _};
 //! use tracing::{error, span};
 //! use tracing_subscriber::layer::SubscriberExt;
 //! use tracing_subscriber::Registry;
 //!
 //! // Create a new OpenTelemetry trace pipeline that prints to stdout
-//! let provider = TracerProvider::builder()
+//! let provider = SdkTracerProvider::builder()
 //!     .with_simple_exporter(opentelemetry_stdout::SpanExporter::default())
 //!     .build();
 //! let tracer = provider.tracer("readme_example");

src/tracer.rs

@@ -152,11 +152,11 @@ mod tests {
     use super::*;
     use crate::OtelData;
     use opentelemetry::trace::TracerProvider as _;
-    use opentelemetry_sdk::trace::{Sampler, TracerProvider};
+    use opentelemetry_sdk::trace::{Sampler, SdkTracerProvider};
 
     #[test]
     fn assigns_default_trace_id_if_missing() {
-        let provider = TracerProvider::default();
+        let provider = SdkTracerProvider::default();
         let tracer = provider.tracer("test");
         let mut builder = SpanBuilder::from_name("empty".to_string());
         builder.span_id = Some(SpanId::from(1u64));
@@ -195,7 +195,7 @@ mod tests {
     #[test]
     fn sampled_context() {
         for (name, sampler, parent_cx, previous_sampling_result, is_sampled) in sampler_data() {
-            let provider = TracerProvider::builder().with_sampler(sampler).build();
+            let provider = SdkTracerProvider::builder().with_sampler(sampler).build();
             let tracer = provider.tracer("test");
             let mut builder = SpanBuilder::from_name("parent".to_string());
             builder.sampling_result = previous_sampling_result;

tests/batch_global_subscriber.rs

@@ -1,9 +1,8 @@
 use futures_util::future::BoxFuture;
 use opentelemetry::{global as otel_global, trace::TracerProvider as _};
 use opentelemetry_sdk::{
-    export::trace::{ExportResult, SpanData, SpanExporter},
-    runtime,
-    trace::TracerProvider,
+    error::OTelSdkResult,
+    trace::{SdkTracerProvider, SpanData, SpanExporter},
 };
 use tokio::runtime::Runtime;
 use tracing::{info_span, subscriber, Level, Subscriber};
@@ -17,7 +16,7 @@ use std::sync::{Arc, Mutex};
 struct TestExporter(Arc<Mutex<Vec<SpanData>>>);
 
 impl SpanExporter for TestExporter {
-    fn export(&mut self, mut batch: Vec<SpanData>) -> BoxFuture<'static, ExportResult> {
+    fn export(&mut self, mut batch: Vec<SpanData>) -> BoxFuture<'static, OTelSdkResult> {
         let spans = self.0.clone();
         Box::pin(async move {
             if let Ok(mut inner) = spans.lock() {
@@ -28,12 +27,12 @@ impl SpanExporter for TestExporter {
     }
 }
 
-fn test_tracer(runtime: &Runtime) -> (TracerProvider, TestExporter, impl Subscriber) {
+fn test_tracer(runtime: &Runtime) -> (SdkTracerProvider, TestExporter, impl Subscriber) {
     let _guard = runtime.enter();
 
     let exporter = TestExporter::default();
-    let provider = TracerProvider::builder()
-        .with_batch_exporter(exporter.clone(), runtime::Tokio)
+    let provider = SdkTracerProvider::builder()
+        .with_batch_exporter(exporter.clone())
         .build();
     let tracer = provider.tracer("test");
 
@@ -70,15 +69,15 @@ fn shutdown_global() {
     let rt = Runtime::new().unwrap();
     let (provider, exporter, subscriber) = test_tracer(&rt);
 
-    otel_global::set_tracer_provider(provider);
+    otel_global::set_tracer_provider(provider.clone());
     subscriber::set_global_default(subscriber).unwrap();
 
     for _ in 0..1000 {
         let _span = info_span!(target: "test_telemetry", "test_span").entered();
     }
 
     // Should flush all batched telemetry spans
-    otel_global::shutdown_tracer_provider();
+    provider.shutdown().unwrap();
 
     let spans = exporter.0.lock().unwrap();
     assert_eq!(spans.len(), 1000);