Merge pull request #3062 from spinframework/update-otel-dependencies

Update otel dependencies

Author: rylev

Cargo.lock

@@ -127,8 +127,8 @@ http = "1"
 http-body-util = "0.1"
 hyper = { version = "1", features = ["full"] }
 itertools = "0.13"
-opentelemetry = { version = "0.27", features = ["metrics", "trace", "logs"] }
-opentelemetry_sdk = { version = "0.27", features = ["rt-tokio", "spec_unstable_logs_enabled", "metrics"] }
+opentelemetry = { version = "0.28", features = ["metrics", "trace", "logs"] }
+opentelemetry_sdk = { version = "0.28", features = ["rt-tokio", "spec_unstable_logs_enabled", "metrics"] }
 rand = "0.8"
 regex = "1"
 reqwest = { version = "0.12", features = ["stream", "blocking"] }
@@ -144,13 +144,13 @@ thiserror = "1"
 tokio = "1"
 toml = "0.8"
 tracing = { version = "0.1", features = ["log"] }
-tracing-opentelemetry = { version = "0.28", default-features = false, features = ["metrics"] }
+tracing-opentelemetry = { version = "0.29", default-features = false, features = ["metrics"] }
 url = "2"
 wasi-common-preview1 = { version = "25.0.0", package = "wasi-common", features = [
   "tokio",
 ] }
-wasm-pkg-common = "0.8"
 wasm-pkg-client = "0.8"
+wasm-pkg-common = "0.8"
 wasmtime = "29.0.1"
 wasmtime-wasi = "29.0.1"
 wasmtime-wasi-http = "29.0.1"

Cargo.toml

@@ -9,8 +9,8 @@ anyhow = { workspace = true }
 http0 = { version = "0.2.9", package = "http" }
 http1 = { version = "1.0.0", package = "http" }
 opentelemetry = { workspace = true }
-opentelemetry-appender-tracing = "0.27"
-opentelemetry-otlp = { version = "0.27", features = ["http-proto", "http", "reqwest-client"] }
+opentelemetry-appender-tracing = "0.28"
+opentelemetry-otlp = { version = "0.28", features = ["grpc-tonic"] }
 opentelemetry_sdk = { workspace = true }
 terminal = { path = "../terminal" }
 tracing = { workspace = true }

crates/telemetry/Cargo.toml

@@ -1,4 +1,4 @@
-use std::{env, time::Duration};
+use std::env;
 
 use opentelemetry::{Key, KeyValue, Value};
 use opentelemetry_sdk::{
@@ -28,20 +28,22 @@ impl SpinResourceDetector {
 }
 
 impl ResourceDetector for SpinResourceDetector {
-    fn detect(&self, _timeout: Duration) -> Resource {
+    fn detect(&self) -> Resource {
         let service_name = env::var(OTEL_SERVICE_NAME)
             .ok()
             .filter(|s| !s.is_empty())
             .map(Value::from)
             .or_else(|| {
                 EnvResourceDetector::new()
-                    .detect(Duration::from_secs(0))
-                    .get(Key::new("service.name"))
+                    .detect()
+                    .get(&Key::new("service.name"))
             })
             .unwrap_or_else(|| "spin".into());
-        Resource::new(vec![
-            KeyValue::new("service.name", service_name),
-            KeyValue::new("service.version", self.spin_version.clone()),
-        ])
+        Resource::builder()
+            .with_attributes(vec![
+                KeyValue::new("service.name", service_name),
+                KeyValue::new("service.version", self.spin_version.clone()),
+            ])
+            .build()
     }
 }

crates/telemetry/src/detector.rs

@@ -1,5 +1,6 @@
 use std::io::IsTerminal;
 
+use anyhow::Context;
 use env::otel_logs_enabled;
 use env::otel_metrics_enabled;
 use env::otel_tracing_enabled;
@@ -47,7 +48,7 @@ pub use propagation::inject_trace_context;
 /// ```no_run
 /// spin_telemetry::metrics::monotonic_counter!(spin.metric_name = 1, metric_attribute = "value");
 /// ```
-pub fn init(spin_version: String) -> anyhow::Result<ShutdownGuard> {
+pub fn init(spin_version: String) -> anyhow::Result<()> {
     // This layer will print all tracing library log messages to stderr.
     let fmt_layer = fmt::layer()
         .with_writer(std::io::stderr)
@@ -65,13 +66,19 @@ pub fn init(spin_version: String) -> anyhow::Result<ShutdownGuard> {
         );
 
     let otel_tracing_layer = if otel_tracing_enabled() {
-        Some(traces::otel_tracing_layer(spin_version.clone())?)
+        Some(
+            traces::otel_tracing_layer(spin_version.clone())
+                .context("failed to initialize otel tracing")?,
+        )
     } else {
         None
     };
 
     let otel_metrics_layer = if otel_metrics_enabled() {
-        Some(metrics::otel_metrics_layer(spin_version.clone())?)
+        Some(
+            metrics::otel_metrics_layer(spin_version.clone())
+                .context("failed to initialize otel metrics")?,
+        )
     } else {
         None
     };
@@ -88,21 +95,9 @@ pub fn init(spin_version: String) -> anyhow::Result<ShutdownGuard> {
     opentelemetry::global::set_text_map_propagator(TraceContextPropagator::new());
 
     if otel_logs_enabled() {
-        logs::init_otel_logging_backend(spin_version)?;
+        logs::init_otel_logging_backend(spin_version)
+            .context("failed to initialize otel logging")?;
     }
 
-    Ok(ShutdownGuard)
-}
-
-/// An RAII implementation for connection to open telemetry services.
-///
-/// Shutdown of the open telemetry services will happen on `Drop`.
-#[must_use]
-pub struct ShutdownGuard;
-
-impl Drop for ShutdownGuard {
-    fn drop(&mut self) {
-        // Give tracer provider a chance to flush any pending traces.
-        opentelemetry::global::shutdown_tracer_provider();
-    }
+    Ok(())
 }

crates/telemetry/src/lib.rs

@@ -1,10 +1,10 @@
-use std::{ascii::escape_default, sync::OnceLock, time::Duration};
+use std::{ascii::escape_default, sync::OnceLock};
 
 use anyhow::bail;
 use opentelemetry::logs::{LogRecord, Logger, LoggerProvider};
 use opentelemetry_sdk::{
-    logs::{BatchConfigBuilder, BatchLogProcessor, Logger as SdkLogger},
-    resource::{EnvResourceDetector, TelemetryResourceDetector},
+    logs::{BatchConfigBuilder, BatchLogProcessor, SdkLogger},
+    resource::{EnvResourceDetector, ResourceDetector, TelemetryResourceDetector},
     Resource,
 };
 
@@ -68,18 +68,17 @@ fn escape_non_utf8_buf(buf: &[u8]) -> String {
 
 /// Initialize the OTel logging backend.
 pub(crate) fn init_otel_logging_backend(spin_version: String) -> anyhow::Result<()> {
-    let resource = Resource::from_detectors(
-        Duration::from_secs(5),
-        vec![
+    let resource = Resource::builder()
+        .with_detectors(&[
             // Set service.name from env OTEL_SERVICE_NAME > env OTEL_RESOURCE_ATTRIBUTES > spin
             // Set service.version from Spin metadata
-            Box::new(SpinResourceDetector::new(spin_version)),
+            Box::new(SpinResourceDetector::new(spin_version)) as Box<dyn ResourceDetector>,
             // Sets fields from env OTEL_RESOURCE_ATTRIBUTES
             Box::new(EnvResourceDetector::new()),
             // Sets telemetry.sdk{name, language, version}
             Box::new(TelemetryResourceDetector),
-        ],
-    );
+        ])
+        .build();
 
     // This will configure the exporter based on the OTEL_EXPORTER_* environment variables. We
     // currently default to using the HTTP exporter but in the future we could select off of the
@@ -95,10 +94,10 @@ pub(crate) fn init_otel_logging_backend(spin_version: String) -> anyhow::Result<
         OtlpProtocol::HttpJson => bail!("http/json OTLP protocol is not supported"),
     };
 
-    let provider = opentelemetry_sdk::logs::LoggerProvider::builder()
+    let provider = opentelemetry_sdk::logs::SdkLoggerProvider::builder()
         .with_resource(resource)
         .with_log_processor(
-            BatchLogProcessor::builder(exporter, opentelemetry_sdk::runtime::Tokio)
+            BatchLogProcessor::builder(exporter)
                 .with_batch_config(BatchConfigBuilder::default().build())
                 .build(),
         )