Merge branch 'tokio-rs:v0.1.x' into v0.1.x

CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.27.0 (October 9, 2024)
+
+### Breaking Changes
+
+- Upgrade to opentelemetry 0.26. Refer to the upstream
+  [changelog](https://github.com/open-telemetry/opentelemetry-rust/releases/tag/opentelemetry-0.26.0)
+  for more information.
+
 # 0.26.0 (September 10, 2024)
 
 ### Breaking Changes

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tracing-opentelemetry"
-version = "0.26.0"
+version = "0.27.0"
 description = "OpenTelemetry integration for tracing"
 homepage = "https://github.com/tokio-rs/tracing-opentelemetry"
 repository = "https://github.com/tokio-rs/tracing-opentelemetry"
@@ -23,8 +23,8 @@ metrics = ["opentelemetry/metrics","opentelemetry_sdk/metrics", "smallvec"]
 metrics_gauge_unstable = ["opentelemetry/otel_unstable"]
 
 [dependencies]
-opentelemetry = { version = "0.25", default-features = false, features = ["trace"] }
-opentelemetry_sdk = { version = "0.25.0", default-features = false, features = ["trace"] }
+opentelemetry = { version = "0.26", default-features = false, features = ["trace"] }
+opentelemetry_sdk = { version = "0.26", 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"] }
@@ -41,11 +41,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.25", features = ["trace", "metrics"] }
-opentelemetry_sdk = { version = "0.25", default-features = false, features = ["trace", "rt-tokio"] }
-opentelemetry-stdout = { version = "0.25", features = ["trace", "metrics"] }
-opentelemetry-otlp = { version = "0.25", features = ["metrics"] }
-opentelemetry-semantic-conventions = "0.25"
+opentelemetry = { version = "0.26", features = ["trace", "metrics"] }
+opentelemetry_sdk = { version = "0.26", default-features = false, features = ["trace", "rt-tokio"] }
+opentelemetry-stdout = { version = "0.26", features = ["trace", "metrics"] }
+opentelemetry-otlp = { version = "0.26", features = ["metrics"] }
+opentelemetry-semantic-conventions = { version = "0.26", features = ["semconv_experimental"] }
 futures-util = { version = "0.3.17", default-features = false }
 tokio = { version = "1", features = ["full"] }
 tokio-stream = "0.1"

examples/opentelemetry-otlp.rs

@@ -1,15 +1,15 @@
 use opentelemetry::{global, trace::TracerProvider, Key, KeyValue};
 use opentelemetry_sdk::{
     metrics::{
-        reader::{DefaultAggregationSelector, DefaultTemporalitySelector},
-        Aggregation, Instrument, MeterProviderBuilder, PeriodicReader, SdkMeterProvider, Stream,
+        reader::DefaultTemporalitySelector, Aggregation, Instrument, MeterProviderBuilder,
+        PeriodicReader, SdkMeterProvider, Stream,
     },
     runtime,
     trace::{BatchConfig, RandomIdGenerator, Sampler, Tracer},
     Resource,
 };
 use opentelemetry_semantic_conventions::{
-    resource::{DEPLOYMENT_ENVIRONMENT_NAME, SERVICE_NAME, SERVICE_VERSION},
+    attribute::{DEPLOYMENT_ENVIRONMENT_NAME, SERVICE_NAME, SERVICE_VERSION},
     SCHEMA_URL,
 };
 use tracing_core::Level;
@@ -32,10 +32,7 @@ fn resource() -> Resource {
 fn init_meter_provider() -> SdkMeterProvider {
     let exporter = opentelemetry_otlp::new_exporter()
         .tonic()
-        .build_metrics_exporter(
-            Box::new(DefaultAggregationSelector::new()),
-            Box::new(DefaultTemporalitySelector::new()),
-        )
+        .build_metrics_exporter(Box::new(DefaultTemporalitySelector::new()))
         .unwrap();
 
     let reader = PeriodicReader::builder(exporter, runtime::Tokio)

src/layer.rs

@@ -310,19 +310,21 @@ impl<'a, 'b> field::Visit for SpanEventVisitor<'a, 'b> {
         let error_msg = value.to_string();
 
         if self.sem_conv_config.error_fields_to_exceptions {
-            self.event_builder
-                .attributes
-                .push(Key::new(FIELD_EXCEPTION_MESSAGE).string(error_msg.clone()));
+            self.event_builder.attributes.push(KeyValue::new(
+                Key::new(FIELD_EXCEPTION_MESSAGE),
+                Value::String(StringValue::from(error_msg.clone())),
+            ));
 
             // NOTE: This is actually not the stacktrace of the exception. This is
             // the "source chain". It represents the heirarchy of errors from the
             // app level to the lowest level such as IO. It does not represent all
             // of the callsites in the code that led to the error happening.
             // `std::error::Error::backtrace` is a nightly-only API and cannot be
             // used here until the feature is stabilized.
-            self.event_builder
-                .attributes
-                .push(Key::new(FIELD_EXCEPTION_STACKTRACE).array(chain.clone()));
+            self.event_builder.attributes.push(KeyValue::new(
+                Key::new(FIELD_EXCEPTION_STACKTRACE),
+                Value::Array(chain.clone().into()),
+            ));
         }
 
         if self.sem_conv_config.error_records_to_exceptions {
@@ -349,12 +351,14 @@ impl<'a, 'b> field::Visit for SpanEventVisitor<'a, 'b> {
             ));
         }
 
-        self.event_builder
-            .attributes
-            .push(Key::new(field.name()).string(error_msg));
-        self.event_builder
-            .attributes
-            .push(Key::new(format!("{}.chain", field.name())).array(chain));
+        self.event_builder.attributes.push(KeyValue::new(
+            Key::new(field.name()),
+            Value::String(StringValue::from(error_msg)),
+        ));
+        self.event_builder.attributes.push(KeyValue::new(
+            Key::new(format!("{}.chain", field.name())),
+            Value::Array(chain.into()),
+        ));
     }
 }
 
@@ -460,7 +464,10 @@ impl<'a> field::Visit for SpanAttributeVisitor<'a> {
             SPAN_STATUS_MESSAGE_FIELD => {
                 self.span_builder_updates.status = Some(otel::Status::error(format!("{:?}", value)))
             }
-            _ => self.record(Key::new(field.name()).string(format!("{:?}", value))),
+            _ => self.record(KeyValue::new(
+                Key::new(field.name()),
+                Value::String(format!("{:?}", value).into()),
+            )),
         }
     }
 
@@ -484,19 +491,31 @@ impl<'a> field::Visit for SpanAttributeVisitor<'a> {
         let error_msg = value.to_string();
 
         if self.sem_conv_config.error_fields_to_exceptions {
-            self.record(Key::new(FIELD_EXCEPTION_MESSAGE).string(error_msg.clone()));
+            self.record(KeyValue::new(
+                Key::new(FIELD_EXCEPTION_MESSAGE),
+                Value::from(error_msg.clone()),
+            ));
 
             // NOTE: This is actually not the stacktrace of the exception. This is
             // the "source chain". It represents the heirarchy of errors from the
             // app level to the lowest level such as IO. It does not represent all
             // of the callsites in the code that led to the error happening.
             // `std::error::Error::backtrace` is a nightly-only API and cannot be
             // used here until the feature is stabilized.
-            self.record(Key::new(FIELD_EXCEPTION_STACKTRACE).array(chain.clone()));
+            self.record(KeyValue::new(
+                Key::new(FIELD_EXCEPTION_STACKTRACE),
+                Value::Array(chain.clone().into()),
+            ));
         }
 
-        self.record(Key::new(field.name()).string(error_msg));
-        self.record(Key::new(format!("{}.chain", field.name())).array(chain));
+        self.record(KeyValue::new(
+            Key::new(field.name()),
+            Value::String(error_msg.into()),
+        ));
+        self.record(KeyValue::new(
+            Key::new(format!("{}.chain", field.name())),
+            Value::Array(chain.into()),
+        ));
     }
 }
 
@@ -996,18 +1015,24 @@ where
 
             #[cfg(feature = "tracing-log")]
             let target = if normalized_meta.is_some() {
-                target.string(meta.target().to_owned())
+                KeyValue::new(target, Value::String(meta.target().to_owned().into()))
             } else {
-                target.string(event.metadata().target())
+                KeyValue::new(target, Value::String(event.metadata().target().into()))
             };
 
             #[cfg(not(feature = "tracing-log"))]
-            let target = target.string(meta.target());
+            let target = KeyValue::new(target, Value::String(meta.target().into()));
 
             let mut otel_event = otel::Event::new(
                 String::new(),
                 crate::time::now(),
-                vec![Key::new("level").string(meta.level().as_str()), target],
+                vec![
+                    KeyValue::new(
+                        Key::new("level"),
+                        Value::String(meta.level().as_str().into()),
+                    ),
+                    target,
+                ],
                 0,
             );
 

tests/metrics_publishing.rs

@@ -2,10 +2,7 @@ use opentelemetry::{metrics::MetricsError, KeyValue};
 use opentelemetry_sdk::{
     metrics::{
         data::{self, Gauge, Histogram, Sum},
-        reader::{
-            AggregationSelector, DefaultAggregationSelector, DefaultTemporalitySelector,
-            MetricReader, TemporalitySelector,
-        },
+        reader::{MetricReader, TemporalitySelector},
         InstrumentKind, ManualReader, MeterProviderBuilder, SdkMeterProvider,
     },
     Resource,
@@ -517,10 +514,7 @@ fn init_subscriber<T>(
     expected_value: T,
     expected_attributes: Option<Vec<KeyValue>>,
 ) -> (impl Subscriber + 'static, TestExporter<T>) {
-    let reader = ManualReader::builder()
-        .with_aggregation_selector(DefaultAggregationSelector::new())
-        .with_temporality_selector(DefaultTemporalitySelector::new())
-        .build();
+    let reader = ManualReader::builder().build();
     let reader = TestReader {
         inner: Arc::new(reader),
     };
@@ -548,12 +542,6 @@ struct TestReader {
     inner: Arc<ManualReader>,
 }
 
-impl AggregationSelector for TestReader {
-    fn aggregation(&self, kind: InstrumentKind) -> opentelemetry_sdk::metrics::Aggregation {
-        self.inner.aggregation(kind)
-    }
-}
-
 impl TemporalitySelector for TestReader {
     fn temporality(&self, kind: InstrumentKind) -> opentelemetry_sdk::metrics::data::Temporality {
         self.inner.temporality(kind)