Use global tracer provider

Signed-off-by: Caleb Schoepp <caleb.schoepp@fermyon.com>

Author: calebschoepp

crates/factor-observe/src/host.rs

@@ -5,7 +5,6 @@ use opentelemetry::trace::Tracer;
 use opentelemetry::Context;
 use spin_core::async_trait;
 use spin_core::wasmtime::component::Resource;
-use spin_telemetry::traces::WASI_OBSERVE_TRACER;
 use spin_world::wasi::clocks0_2_0::wall_clock::Datetime;
 use spin_world::wasi::observe::traces::{self, KeyValue, Span as WitSpan};
 use tracing_opentelemetry::OpenTelemetrySpanExt;
@@ -36,12 +35,7 @@ impl traces::HostSpan for InstanceState {
         };
 
         // Create the underlying opentelemetry span
-        let otel_span = WASI_OBSERVE_TRACER
-            .lock()
-            .unwrap()
-            .clone()
-            .unwrap()
-            .start_with_context(name, &parent_context);
+        let otel_span = self.tracer.start_with_context(name, &parent_context);
 
         let span_id = otel_span.span_context().span_id().to_string();
 

crates/factor-observe/src/lib.rs

@@ -3,7 +3,11 @@ mod host;
 use std::sync::{Arc, RwLock};
 
 use indexmap::IndexMap;
-use opentelemetry::{global::ObjectSafeSpan, trace::TraceContextExt, Context};
+use opentelemetry::{
+    global::{self, BoxedTracer, ObjectSafeSpan},
+    trace::TraceContextExt,
+    Context,
+};
 use spin_factors::{Factor, SelfInstanceBuilder};
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 
@@ -32,14 +36,18 @@ impl Factor for ObserveFactor {
 
     fn prepare<T: spin_factors::RuntimeFactors>(
         &self,
-        _ctx: spin_factors::PrepareContext<Self>,
+        ctx: spin_factors::PrepareContext<Self>,
         _builders: &mut spin_factors::InstanceBuilders<T>,
     ) -> anyhow::Result<Self::InstanceBuilder> {
+        // TODO(Lann): Is it fine that we're using BoxedTracer and BoxedSpan? Are there perf tradeoffs?
+        // TODO(Lann): Would it make sense to put the tracer on the app state and just hold a reference to it in the instance state?
+        let tracer = global::tracer(ctx.app_component().app.id().to_string());
         Ok(InstanceState {
             state: Arc::new(RwLock::new(State {
                 guest_spans: table::Table::new(1024),
                 active_spans: Default::default(),
             })),
+            tracer,
         })
     }
 }
@@ -52,6 +60,7 @@ impl ObserveFactor {
 
 pub struct InstanceState {
     pub(crate) state: Arc<RwLock<State>>,
+    pub(crate) tracer: BoxedTracer,
 }
 
 impl SelfInstanceBuilder for InstanceState {}
@@ -65,7 +74,10 @@ impl InstanceState {
     }
 }
 
-/// Internal state of the observe factor.
+/// Internal state of the ObserveFactor instance state.
+///
+/// This data lives here rather than directly on InstanceState so that we can have multiple things
+/// take Arc references to it.
 pub(crate) struct State {
     /// A resource table that holds the guest spans.
     pub guest_spans: table::Table<GuestSpan>,
@@ -78,10 +90,10 @@ pub(crate) struct State {
     pub active_spans: IndexMap<String, u32>,
 }
 
-/// The WIT resource Span. Effectively wraps an [opentelemetry_sdk::trace::Span].
+/// The WIT resource Span. Effectively wraps an [opentelemetry::global::BoxedSpan].
 pub struct GuestSpan {
-    /// The [opentelemetry_sdk::trace::Span] we use to do the actual tracing work.
-    pub inner: opentelemetry_sdk::trace::Span,
+    /// The [opentelemetry::global::BoxedSpan] we use to do the actual tracing work.
+    pub inner: opentelemetry::global::BoxedSpan,
 }
 
 /// TODO comment

crates/telemetry/src/traces.rs

@@ -1,10 +1,9 @@
-use std::{sync::Mutex, time::Duration};
+use std::time::Duration;
 
 use anyhow::bail;
 use opentelemetry_otlp::SpanExporterBuilder;
 use opentelemetry_sdk::{
     resource::{EnvResourceDetector, TelemetryResourceDetector},
-    trace::Tracer,
     Resource,
 };
 use tracing::Subscriber;
@@ -13,9 +12,6 @@ use tracing_subscriber::{registry::LookupSpan, EnvFilter, Layer};
 use crate::detector::SpinResourceDetector;
 use crate::env::OtlpProtocol;
 
-// TODO(Caleb): I think there is probably a better way to do this than just a global tracer. Maybe I should make telemetry a factor?
-pub static WASI_OBSERVE_TRACER: Mutex<Option<Tracer>> = Mutex::new(None);
-
 /// Constructs a layer for the tracing subscriber that sends spans to an OTEL collector.
 ///
 /// It pulls OTEL configuration from the environment based on the variables defined
@@ -53,8 +49,6 @@ pub(crate) fn otel_tracing_layer<S: Subscriber + for<'span> LookupSpan<'span>>(
         .with_trace_config(opentelemetry_sdk::trace::config().with_resource(resource))
         .install_batch(opentelemetry_sdk::runtime::Tokio)?;
 
-    *WASI_OBSERVE_TRACER.lock().unwrap() = Some(tracer.clone());
-
     let env_filter = match EnvFilter::try_from_env("SPIN_OTEL_TRACING_LEVEL") {
         Ok(filter) => filter,
         // If it isn't set or it fails to parse default to info