NH-2313 Add basic TraceState handling and W3C trace context propagation

opentelemetry_distro_solarwinds/distro.py

@@ -2,11 +2,13 @@
 
 from opentelemetry import trace
 from opentelemetry.instrumentation.distro import BaseDistro
+from opentelemetry.instrumentation.propagators import set_global_response_propagator
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 
 from opentelemetry_distro_solarwinds.exporter import SolarWindsSpanExporter
-from opentelemetry_distro_solarwinds.sampler import ParentBasedAoSampler
+from opentelemetry_distro_solarwinds.response_propagator import SolarWindsTraceResponsePropagator
+from opentelemetry_distro_solarwinds.sampler import ParentBasedSwSampler
 
 
 class SolarWindsDistro(BaseDistro):
@@ -16,9 +18,11 @@ class SolarWindsDistro(BaseDistro):
         - no functionality added at this time
     """
     def _configure(self, **kwargs):
-        # automatically make use of custom SolarWinds sampler
+        # Automatically make use of custom SolarWinds sampler
         trace.set_tracer_provider(
-            TracerProvider(sampler=ParentBasedAoSampler()))
+            TracerProvider(sampler=ParentBasedSwSampler()))
         # Automatically configure the SolarWinds Span exporter
         span_exporter = BatchSpanProcessor(SolarWindsSpanExporter())
         trace.get_tracer_provider().add_span_processor(span_exporter)
+        # Set global HTTP response propagator
+        set_global_response_propagator(SolarWindsTraceResponsePropagator())

opentelemetry_distro_solarwinds/exporter.py

@@ -11,7 +11,7 @@
 
 from opentelemetry_distro_solarwinds.extension.oboe import (Context, Metadata,
                                                             Reporter)
-from opentelemetry_distro_solarwinds.ot_ao_transformer import transform_id
+from opentelemetry_distro_solarwinds.w3c_transformer import W3CTransformer
 
 logger = logging.getLogger(__file__)
 
@@ -36,15 +36,15 @@ def export(self, spans):
             md = self._build_metadata(span.get_span_context())
             if span.parent and span.parent.is_valid:
                 # If there is a parent, we need to add an edge to this parent to this entry event
-                logger.debug("Continue trace from %s", md.toString())
+                logger.debug("Continue trace from {}".format(md.toString()))
                 parent_md = self._build_metadata(span.parent)
                 evt = Context.startTrace(md, int(span.start_time / 1000),
                                          parent_md)
             else:
                 # In OpenTelemrtry, there are no events with individual IDs, but only a span ID
                 # and trace ID. Thus, the entry event needs to be generated such that it has the
                 # same op ID as the span ID of the OTel span.
-                logger.debug("Start a new trace %s", md.toString())
+                logger.debug("Start a new trace {}".format(md.toString()))
                 evt = Context.startTrace(md, int(span.start_time / 1000))
             evt.addInfo('Layer', span.name)
             evt.addInfo('Language', 'Python')
@@ -122,4 +122,6 @@ def _initialize_solarwinds_reporter(self):
 
     @staticmethod
     def _build_metadata(span_context):
-        return Metadata.fromString(transform_id(span_context))
+        return Metadata.fromString(
+            W3CTransformer.traceparent_from_context(span_context)
+        )

opentelemetry_distro_solarwinds/propagator.py

@@ -0,0 +1,100 @@
+import logging
+import typing
+
+from opentelemetry import trace
+from opentelemetry.context.context import Context
+from opentelemetry.propagators import textmap
+from opentelemetry.trace.span import TraceState
+
+from opentelemetry_distro_solarwinds.traceoptions import XTraceOptions
+from opentelemetry_distro_solarwinds.w3c_transformer import W3CTransformer
+
+logger = logging.getLogger(__file__)
+
+class SolarWindsPropagator(textmap.TextMapPropagator):
+    """Extracts and injects SolarWinds headers for trace propagation.
+    Must be used in composite with TraceContextTextMapPropagator.
+    """
+    _TRACESTATE_HEADER_NAME = "tracestate"
+    _XTRACEOPTIONS_HEADER_NAME = "x-trace-options"
+    _XTRACEOPTIONS_SIGNATURE_HEADER_NAME = "x-trace-options-signature"
+
+    def extract(
+        self,
+        carrier: textmap.CarrierT,
+        context: typing.Optional[Context] = None,
+        getter: textmap.Getter = textmap.default_getter,
+    ) -> Context:
+        """Extracts sw trace options and signature from carrier into OTel
+        Context. Note: tracestate is extracted by TraceContextTextMapPropagator
+        """
+        if context is None:
+            context = Context()
+
+        xtraceoptions_header = getter.get(
+            carrier,
+            self._XTRACEOPTIONS_HEADER_NAME
+        )
+        if not xtraceoptions_header:
+            logger.debug("No xtraceoptions to extract; ignoring signature")
+            return context
+        logger.debug("Extracted xtraceoptions_header: {}".format(
+            xtraceoptions_header[0]
+        ))
+
+        signature_header = getter.get(
+            carrier,
+            self._XTRACEOPTIONS_SIGNATURE_HEADER_NAME
+        )
+        if signature_header:
+            xtraceoptions = XTraceOptions(
+                context,
+                xtraceoptions_header[0],
+                signature_header[0],
+            )
+        else:
+            xtraceoptions = XTraceOptions(
+                context,
+                xtraceoptions_header[0],
+            )
+        context.update(dict(xtraceoptions))
+        return context
+
+    def inject(
+        self,
+        carrier: textmap.CarrierT,
+        context: typing.Optional[Context] = None,
+        setter: textmap.Setter = textmap.default_setter,
+    ) -> None:
+        """Injects sw tracestate and trace options from SpanContext into carrier for HTTP request"""
+        span = trace.get_current_span(context)
+        span_context = span.get_span_context()
+        trace_state = span_context.trace_state
+        sw_value = W3CTransformer.sw_from_context(span_context)
+
+        # Prepare carrier with context's or new tracestate
+        if trace_state:
+            # Check if trace_state already contains sw KV
+            if "sw" in trace_state.keys():
+                # If so, modify current span_id and trace_flags, and move to beginning of list
+                logger.debug("Updating trace state for injection with {}".format(sw_value))
+                trace_state = trace_state.update("sw", sw_value)
+
+            else:
+                # If not, add sw KV to beginning of list
+                logger.debug("Adding KV to trace state for injection with {}".format(sw_value))
+                trace_state = trace_state.add("sw", sw_value)
+        else:
+            logger.debug("Creating new trace state for injection with {}".format(sw_value))
+            trace_state = TraceState([("sw", sw_value)])
+
+        setter.set(
+            carrier, self._TRACESTATE_HEADER_NAME, trace_state.to_header()
+        )
+
+    @property
+    def fields(self) -> typing.Set[str]:
+        """Returns a set with the fields set in `inject`"""
+        return {
+            self._TRACESTATE_HEADER_NAME
+        }

opentelemetry_distro_solarwinds/response_propagator.py

@@ -0,0 +1,74 @@
+import logging
+import typing
+
+from opentelemetry import trace
+from opentelemetry.context.context import Context
+from opentelemetry.instrumentation.propagators import ResponsePropagator
+from opentelemetry.propagators import textmap
+from opentelemetry.trace.span import TraceState
+
+from opentelemetry_distro_solarwinds.traceoptions import XTraceOptions
+from opentelemetry_distro_solarwinds.w3c_transformer import W3CTransformer
+
+logger = logging.getLogger(__file__)
+
+class SolarWindsTraceResponsePropagator(ResponsePropagator):
+    """Propagator that injects SW values into HTTP responses"""
+    _HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS = "Access-Control-Expose-Headers"
+    _XTRACE_HEADER_NAME = "x-trace"
+    _XTRACEOPTIONS_RESPONSE_HEADER_NAME = "x-trace-options-response"
+
+    def inject(
+        self,
+        carrier: textmap.CarrierT,
+        context: typing.Optional[Context] = None,
+        setter: textmap.Setter = textmap.default_setter,
+    ) -> None:
+        """Injects x-trace and options-response into the HTTP response carrier."""
+        span = trace.get_current_span(context)
+        span_context = span.get_span_context()
+        if span_context == trace.INVALID_SPAN_CONTEXT:
+            return
+
+        x_trace = W3CTransformer.traceparent_from_context(span_context)
+        setter.set(
+            carrier,
+            self._XTRACE_HEADER_NAME,
+            x_trace,
+        )
+        exposed_headers = [self._XTRACE_HEADER_NAME]
+
+        xtraceoptions_response = self.recover_response_from_tracestate(
+            span_context.trace_state
+        )
+        if xtraceoptions_response:
+            exposed_headers.append("{}".format(
+                self._XTRACEOPTIONS_RESPONSE_HEADER_NAME
+            ))
+            setter.set(
+                carrier,
+                self._XTRACEOPTIONS_RESPONSE_HEADER_NAME,
+                xtraceoptions_response,
+            )
+        setter.set(
+            carrier,
+            self._HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS,
+            ",".join(exposed_headers),
+        )
+
+    def recover_response_from_tracestate(
+        self,
+        tracestate: TraceState
+    ) -> str:
+        """Use tracestate to recover xtraceoptions response by
+        converting delimiters:
+        `####` becomes `=`
+        `....` becomes `,`
+        """
+        sanitized = tracestate.get(
+            XTraceOptions.get_sw_xtraceoptions_response_key(),
+            None
+        )
+        if not sanitized:
+            return
+        return sanitized.replace("####", "=").replace("....", ",")