extract parent span

Author: jan-xyz

opentelemetry-instrumentation-tower/Cargo.toml

@@ -22,7 +22,7 @@ futures-util = { version = "0.3", default-features = false }
 http = { version = "1", features = ["std"], default-features = false }
 http-body = { version = "1", default-features = false }
 opentelemetry = { workspace = true, features = ["futures", "metrics", "trace"] }
-opentelemetry_sdk = { workspace = true, features = ["trace"] }
+opentelemetry-http = "0.31"
 opentelemetry-semantic-conventions = { workspace = true, features = ["semconv_experimental"] }
 pin-project-lite = { version = "0.2", default-features = false }
 tower-service = { version = "0.3", default-features = false }

opentelemetry-instrumentation-tower/src/lib.rs

@@ -12,11 +12,12 @@ use std::{fmt, result};
 use axum::extract::MatchedPath;
 use futures_util::ready;
 use opentelemetry::global::{self, BoxedTracer};
+use opentelemetry::metrics::Meter;
 use opentelemetry::metrics::{Histogram, MeterProvider, UpDownCounter};
 use opentelemetry::trace::{SpanKind, Status, TraceContextExt, Tracer, TracerProvider};
 use opentelemetry::Context as OtelContext;
 use opentelemetry::KeyValue;
-use opentelemetry_sdk::trace::SdkTracerProvider;
+use opentelemetry_http::HeaderExtractor;
 use opentelemetry_semantic_conventions as semconv;
 use pin_project_lite::pin_project;
 use tower_layer::Layer;
@@ -123,14 +124,11 @@ where
 }
 
 /// State scoped to the entire middleware Layer.
-///
-/// Holds metrics instruments.
 struct HTTPLayerState {
     pub server_request_duration: Histogram<f64>,
     pub server_active_requests: UpDownCounter<i64>,
     pub server_request_body_size: Histogram<u64>,
     pub server_response_body_size: Histogram<u64>,
-    pub tracer_provider: Option<SdkTracerProvider>,
 }
 
 #[derive(Clone)]
@@ -140,6 +138,7 @@ pub struct HTTPService<S, ReqExt = NoOpExtractor, ResExt = NoOpExtractor> {
     request_extractor: ReqExt,
     response_extractor: ResExt,
     inner_service: S,
+    tracer: Arc<BoxedTracer>,
 }
 
 #[derive(Clone)]
@@ -148,6 +147,7 @@ pub struct HTTPLayer<ReqExt = NoOpExtractor, ResExt = NoOpExtractor> {
     state: Arc<HTTPLayerState>,
     request_extractor: ReqExt,
     response_extractor: ResExt,
+    tracer: Arc<BoxedTracer>,
 }
 
 impl HTTPLayer {
@@ -164,8 +164,8 @@ impl Default for HTTPLayer {
 }
 
 pub struct HTTPLayerBuilder<ReqExt = NoOpExtractor, ResExt = NoOpExtractor> {
-    tracer_provider: Option<SdkTracerProvider>,
-    meter_provider: Option<Box<dyn MeterProvider + Send + Sync>>,
+    tracer_provider: Option<BoxedTracer>,
+    meter: Option<Meter>,
     req_dur_bounds: Option<Vec<f64>>,
     request_extractor: ReqExt,
     response_extractor: ResExt,
@@ -211,7 +211,7 @@ impl HTTPLayerBuilder {
     pub fn builder() -> Self {
         HTTPLayerBuilder {
             tracer_provider: None,
-            meter_provider: None,
+            meter: None,
             req_dur_bounds: Some(LIBRARY_DEFAULT_HTTP_SERVER_DURATION_BOUNDARIES.to_vec()),
             request_extractor: NoOpExtractor,
             response_extractor: NoOpExtractor,
@@ -229,7 +229,7 @@ impl<ReqExt, ResExt> HTTPLayerBuilder<ReqExt, ResExt> {
         NewReqExt: RequestAttributeExtractor<B>,
     {
         HTTPLayerBuilder {
-            meter_provider: self.meter_provider,
+            meter: self.meter,
             tracer_provider: self.tracer_provider,
             req_dur_bounds: self.req_dur_bounds,
             request_extractor: extractor,
@@ -246,7 +246,7 @@ impl<ReqExt, ResExt> HTTPLayerBuilder<ReqExt, ResExt> {
         NewResExt: ResponseAttributeExtractor<B>,
     {
         HTTPLayerBuilder {
-            meter_provider: self.meter_provider,
+            meter: self.meter,
             tracer_provider: self.tracer_provider,
             req_dur_bounds: self.req_dur_bounds,
             request_extractor: self.request_extractor,
@@ -281,14 +281,20 @@ impl<ReqExt, ResExt> HTTPLayerBuilder<ReqExt, ResExt> {
             .req_dur_bounds
             .unwrap_or_else(|| LIBRARY_DEFAULT_HTTP_SERVER_DURATION_BOUNDARIES.to_vec());
 
+        let tracer: BoxedTracer = self
+            .tracer_provider
+            .unwrap_or_else(|| global::tracer("opentelemetry-instrumentation-tower"));
+        let tracer = Arc::new(tracer);
+
+        let meter: Meter = self
+            .meter
+            .unwrap_or_else(|| global::meter("opentelemetry-instrumentation-tower"));
+
         Ok(HTTPLayer {
-            state: Arc::from(Self::make_state(
-                self.meter_provider,
-                self.tracer_provider,
-                req_dur_bounds,
-            )),
+            state: Arc::from(Self::make_state(meter, req_dur_bounds)),
             request_extractor: self.request_extractor,
             response_extractor: self.response_extractor,
+            tracer: tracer,
         })
     }
 
@@ -303,26 +309,22 @@ impl<ReqExt, ResExt> HTTPLayerBuilder<ReqExt, ResExt> {
     where
         M: MeterProvider + Send + Sync + 'static,
     {
-        self.meter_provider = Some(Box::new(provider));
+        self.meter = Some(provider.meter("opentelemetry-intrumentation-tower"));
         self
     }
 
     /// Set a meter provider to use for creating a meter.
     /// If none is specified, the global provider is used.
-    pub fn with_tracer_provider(mut self, provider: SdkTracerProvider) -> Self {
-        self.tracer_provider = Some(provider);
+    pub fn with_tracer_provider<T>(mut self, provider: T) -> Self
+    where
+        T: TracerProvider + Send + Sync + 'static,
+    {
+        self.tracer_provider =
+            Some(Box::new(provider.tracer("opentelemetry-intrumentation-tower")) as BoxedTracer);
         self
     }
 
-    fn make_state(
-        meter_provider: Option<Box<dyn MeterProvider + Send + Sync>>,
-        tracer_provider: Option<SdkTracerProvider>,
-        req_dur_bounds: Vec<f64>,
-    ) -> HTTPLayerState {
-        let meter = match meter_provider {
-            Some(provider) => provider.meter("opentelemetry-instrumentation-tower"),
-            None => global::meter("opentelemetry-instrumentation-tower"),
-        };
+    fn make_state(meter: Meter, req_dur_bounds: Vec<f64>) -> HTTPLayerState {
         HTTPLayerState {
             server_request_duration: meter
                 .f64_histogram(Cow::from(HTTP_SERVER_DURATION_METRIC))
@@ -345,7 +347,6 @@ impl<ReqExt, ResExt> HTTPLayerBuilder<ReqExt, ResExt> {
                 .with_description("Size of HTTP server response bodies.")
                 .with_unit(HTTP_SERVER_RESPONSE_BODY_SIZE_UNIT)
                 .build(),
-            tracer_provider,
         }
     }
 }
@@ -363,6 +364,7 @@ where
             request_extractor: self.request_extractor.clone(),
             response_extractor: self.response_extractor.clone(),
             inner_service: service,
+            tracer: self.tracer.clone(),
         }
     }
 }
@@ -450,7 +452,11 @@ where
         // Extract custom request attributes
         let custom_request_attributes = self.request_extractor.extract_attributes(&req);
 
-        // Start tracing span
+        // Extract the context from the incoming request headers
+        let parent_cx = global::get_text_map_propagator(|propagator| {
+            propagator.extract(&HeaderExtractor(req.headers()))
+        });
+
         let mut span_attributes = vec![
             KeyValue::new(semconv::trace::HTTP_REQUEST_METHOD, method.clone()),
             url_scheme_kv.clone(),
@@ -473,18 +479,12 @@ where
 
         let span_name = format!("{} {}", method, req.uri().path());
 
-        let tracer = match &self.state.tracer_provider {
-            Some(tp) => {
-                BoxedTracer::new(Box::new(tp.tracer("opentelemetry-instrumentation-tower")))
-            }
-            None => global::tracer("opentelemetry-instrumentation-tower"),
-        };
-
-        let span = tracer
+        let span = self
+            .tracer
             .span_builder(span_name)
             .with_kind(SpanKind::Server)
             .with_attributes(span_attributes)
-            .start(&tracer);
+            .start_with_context(self.tracer.as_ref(), &parent_cx);
 
         let cx = OtelContext::current_with_span(span);
 
@@ -618,7 +618,9 @@ mod tests {
     use super::*;
 
     use http::{Request, Response, StatusCode};
+    use opentelemetry::global::ObjectSafeTracerProvider;
     use opentelemetry::trace::{FutureExt, TraceContextExt, Tracer};
+    use opentelemetry::InstrumentationScope;
     use opentelemetry_sdk::metrics::SdkMeterProvider;
     use opentelemetry_sdk::metrics::{
         data::{AggregatedMetrics, MetricData},