fix: update opentelemetry version

Signed-off-by: Andrew Steurer <[email protected]>

Author: asteurer

Cargo.toml

@@ -83,7 +83,7 @@ openssl = { version = "0.10" }
 anyhow = { workspace = true, features = ["backtrace"] }
 conformance = { path = "tests/conformance-tests" }
 conformance-tests = { workspace = true }
-fake-opentelemetry-collector = "0.21.1"
+fake-opentelemetry-collector = "0.26"
 hex = "0.4"
 http-body-util = { workspace = true }
 hyper = { workspace = true }
@@ -143,6 +143,9 @@ hyper-util = { version = "0.1", features = ["tokio"] }
 indexmap = "2"
 itertools = "0.14"
 lazy_static = "1.5"
+opentelemetry = "0.28"
+opentelemetry-otlp = "0.28"
+opentelemetry_sdk = "0.28"
 path-absolutize = "3"
 quote = "1"
 rand = "0.9"
@@ -169,6 +172,7 @@ toml = "0.8"
 toml_edit = "0.22"
 tower-service = "0.3.3"
 tracing = { version = "0.1.41", features = ["log"] }
+tracing-opentelemetry = "0.29"
 url = "2"
 walkdir = "2"
 wasm-encoder = "0.236.1"

crates/factor-otel/Cargo.toml

@@ -9,7 +9,7 @@ anyhow = { workspace = true }
 indexmap = "2.2.6"
 opentelemetry = { workspace = true }
 opentelemetry_sdk = { workspace = true }
-opentelemetry-otlp = { version = "0.27", features = ["http-proto", "http", "reqwest-client"] }
+opentelemetry-otlp = { workspace = true, features = ["http-proto", "http", "reqwest-client"] }
 spin-core = { path = "../core" }
 spin-factors = { path = "../factors" }
 spin-resource-table = { path = "../table" }

crates/factor-otel/src/lib.rs

@@ -2,7 +2,6 @@ mod host;
 
 use std::{
     sync::{Arc, RwLock},
-    time::Duration,
 };
 
 use anyhow::bail;
@@ -13,28 +12,24 @@ use opentelemetry::{
 };
 use opentelemetry_sdk::{
     resource::{EnvResourceDetector, TelemetryResourceDetector},
-    runtime::Tokio,
     trace::{BatchSpanProcessor, SpanProcessor},
     Resource,
 };
-use spin_factors::{Factor, PrepareContext, RuntimeFactors, SelfInstanceBuilder};
+use spin_factors::{Factor, FactorData, PrepareContext, RuntimeFactors, SelfInstanceBuilder};
 use spin_telemetry::{detector::SpinResourceDetector, env::OtlpProtocol};
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 
 pub struct OtelFactor {
-    processor: Arc<BatchSpanProcessor<Tokio>>,
+    processor: Arc<BatchSpanProcessor>,
 }
 
 impl Factor for OtelFactor {
     type RuntimeConfig = ();
     type AppState = ();
     type InstanceBuilder = InstanceState;
 
-    fn init<T: Send + 'static>(
-        &mut self,
-        mut ctx: spin_factors::InitContext<T, Self>,
-    ) -> anyhow::Result<()> {
-        ctx.link_bindings(spin_world::wasi::otel::tracing::add_to_linker)?;
+    fn init(&mut self, ctx: &mut impl spin_factors::InitContext<Self>) -> anyhow::Result<()> {
+        ctx.link_bindings(spin_world::wasi::otel::tracing::add_to_linker::<_, FactorData<Self>>)?;
         Ok(())
     }
 
@@ -71,25 +66,24 @@ impl OtelFactor {
                 .build()?,
             OtlpProtocol::HttpJson => bail!("http/json OTLP protocol is not supported"),
         };
-        let mut processor = opentelemetry_sdk::trace::BatchSpanProcessor::builder(
-            exporter,
-            opentelemetry_sdk::runtime::Tokio,
-        )
-        .build();
+
+        let mut processor = opentelemetry_sdk::trace::BatchSpanProcessor::builder(exporter).build();
+
         // This is a hack b/c we know the version of this crate will be the same as the version of Spin
         let spin_version = env!("CARGO_PKG_VERSION").to_string();
-        processor.set_resource(&Resource::from_detectors(
-            Duration::from_secs(5),
-            vec![
+
+        let detectors: &[Box<dyn opentelemetry_sdk::resource::ResourceDetector>; 3] = &[
                 // 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)),
                 // Sets fields from env OTEL_RESOURCE_ATTRIBUTES
                 Box::new(EnvResourceDetector::new()),
                 // Sets telemetry.sdk{name, language, version}
                 Box::new(TelemetryResourceDetector),
-            ],
-        ));
+        ];
+
+        processor.set_resource(&Resource::builder().with_detectors(detectors).build());
+
         Ok(Self {
             processor: Arc::new(processor),
         })
@@ -98,7 +92,7 @@ impl OtelFactor {
 
 pub struct InstanceState {
     pub(crate) state: Arc<RwLock<State>>,
-    pub(crate) processor: Arc<BatchSpanProcessor<Tokio>>,
+    pub(crate) processor: Arc<BatchSpanProcessor>,
 }
 
 impl SelfInstanceBuilder for InstanceState {}

crates/factor-outbound-mqtt/src/host.rs

@@ -4,6 +4,7 @@ use anyhow::Result;
 use spin_core::{async_trait, wasmtime::component::Resource};
 use spin_factor_outbound_networking::config::allowed_hosts::OutboundAllowedHosts;
 use spin_world::v2::mqtt::{self as v2, Connection, Error, Qos};
+use spin_factor_otel::OtelContext;
 use tracing::{instrument, Level};
 
 use crate::ClientCreator;

crates/factor-outbound-mysql/src/lib.rs

@@ -7,9 +7,7 @@ use spin_factor_otel::OtelContext;
 use spin_factor_outbound_networking::{
     config::allowed_hosts::OutboundAllowedHosts, OutboundNetworkingFactor,
 };
-use spin_factor_outbound_networking::{OutboundAllowedHosts, OutboundNetworkingFactor};
 use spin_factors::{Factor, FactorData, InitContext, RuntimeFactors, SelfInstanceBuilder};
-use spin_factors::{Factor, InitContext, RuntimeFactors, SelfInstanceBuilder};
 use spin_world::v1::mysql as v1;
 use spin_world::v2::mysql::{self as v2};
 

crates/factor-outbound-redis/src/host.rs

@@ -3,7 +3,6 @@ use redis::{aio::MultiplexedConnection, AsyncCommands, FromRedisValue, Value};
 use spin_core::wasmtime::component::Resource;
 use spin_factor_outbound_networking::config::allowed_hosts::OutboundAllowedHosts;
 use spin_factor_otel::OtelContext;
-use spin_factor_outbound_networking::OutboundAllowedHosts;
 use spin_world::v1::{redis as v1, redis_types};
 use spin_world::v2::redis::{
     self as v2, Connection as RedisConnection, Error, RedisParameter, RedisResult,

crates/factor-sqlite/src/lib.rs

@@ -9,7 +9,6 @@ use host::InstanceState;
 use async_trait::async_trait;
 use spin_factors::{anyhow, Factor, FactorData};
 use spin_factor_otel::OtelContext;
-use spin_factors::{anyhow, Factor};
 use spin_locked_app::MetadataKey;
 use spin_world::spin::sqlite::sqlite as v3;
 use spin_world::v1::sqlite as v1;

crates/telemetry/Cargo.toml

@@ -10,11 +10,11 @@ http0 = { version = "0.2.9", package = "http" }
 http1 = { version = "1.0.0", package = "http" }
 opentelemetry = { version = "0.28", features = ["metrics", "trace", "logs"] }
 opentelemetry-appender-tracing = "0.28"
-opentelemetry-otlp = { version = "0.28", features = ["grpc-tonic"] }
-opentelemetry_sdk = { version = "0.28", features = ["rt-tokio", "spec_unstable_logs_enabled", "metrics"] }
+opentelemetry-otlp = { workspace = true, features = ["grpc-tonic"] }
+opentelemetry_sdk = { workspace = true, features = ["rt-tokio", "spec_unstable_logs_enabled", "metrics"] }
 terminal = { path = "../terminal" }
 tracing = { workspace = true }
-tracing-opentelemetry = { version = "0.29", default-features = false, features = ["metrics"] }
+tracing-opentelemetry = { workspace = true, default-features = false, features = ["metrics"] }
 tracing-subscriber = { version = "0.3", default-features = false, features = ["smallvec", "fmt", "ansi", "std", "env-filter", "json", "registry"] }
 
 [features]

crates/trigger-http/src/wasi.rs

@@ -93,6 +93,7 @@ impl HttpExecutor for WasiHttpExecutor<'_> {
             HandlerType::Wagi(_) => unreachable!("should have used WagiExecutor instead"),
         };
 
+        let span = tracing::debug_span!("execute_wasi");
         let handle = task::spawn(
             async move {
                 let result = match handler {

crates/world/src/conversions.rs

@@ -562,7 +562,7 @@ mod otel {
     use wasi::clocks0_2_0::wall_clock;
     use wasi::otel::tracing as wasi_otel;
 
-    impl From<wasi_otel::SpanData> for opentelemetry_sdk::export::trace::SpanData {
+    impl From<wasi_otel::SpanData> for opentelemetry_sdk::trace::SpanData {
         fn from(value: wasi_otel::SpanData) -> Self {
             let mut span_events = SpanEvents::default();
             span_events.events = value.events.into_iter().map(Into::into).collect();