feat(otel): support deactivating active traces

Author: mabdinur

ddtrace/_trace/provider.py

@@ -1,5 +1,6 @@
 import abc
 import contextvars
+from contextvars import Token
 from typing import Any
 from typing import Optional
 from typing import Union
@@ -63,10 +64,11 @@ def _has_active_context(self) -> bool:
         ctx = _DD_CONTEXTVAR.get()
         return ctx is not None
 
-    def activate(self, ctx: Optional[ActiveTrace]) -> None:
+    def activate(self, ctx: Optional[ActiveTrace]) -> Token:
         """Makes the given context active in the current execution."""
-        _DD_CONTEXTVAR.set(ctx)
+        token = _DD_CONTEXTVAR.set(ctx)
         super(DefaultContextProvider, self).activate(ctx)
+        return token
 
     def active(self) -> Optional[ActiveTrace]:
         """Returns the active span or context for the current execution."""
@@ -95,3 +97,6 @@ def _update_active(self, span: Span) -> Optional[ActiveTrace]:
         if new_active is not span:
             self.activate(new_active)
         return new_active
+
+    def _deactivate(self, token: Token) -> None:
+        _DD_CONTEXTVAR.reset(token)

ddtrace/internal/opentelemetry/context.py

@@ -30,14 +30,15 @@ def attach(self, otel_context):
         otel_span = get_current_span(otel_context)
         if otel_span:
             if isinstance(otel_span, Span):
-                self._ddcontext_provider.activate(otel_span._ddspan)
+                token = self._ddcontext_provider.activate(otel_span._ddspan)
                 ddcontext = otel_span._ddspan.context
             elif isinstance(otel_span, OtelSpan):
                 trace_id, span_id, _, tf, ts, _ = otel_span.get_span_context()
                 trace_state = ts.to_header() if ts else None
                 ddcontext = _TraceContext._get_context(trace_id, span_id, tf, trace_state)
-                self._ddcontext_provider.activate(ddcontext)
+                token = self._ddcontext_provider.activate(ddcontext)
             else:
+                token = None
                 ddcontext = None
                 log.error(
                     "Programming ERROR: ddtrace does not support activating spans with the type: %s. Please open a "
@@ -54,9 +55,7 @@ def attach(self, otel_context):
                     for key, value in otel_baggage.items():
                         ddcontext._baggage[key] = value  # potentially convert to json
 
-        # A return value with the type `object` is required by the otel api to remove/deactivate spans.
-        # Since manually deactivating spans is not supported by ddtrace this object will never be used.
-        return object()
+        return token
 
     def get_current(self):
         """
@@ -100,10 +99,9 @@ def get_current(self):
 
     def detach(self, token):
         """
-        NOP, The otel api uses this method to deactivate spans but this operation is not supported by
-        the datadog context provider.
+        Resets the datadog contextvar to the previous active context.
         """
-        pass
+        self._ddcontext_provider._deactivate(token)
 
     @property
     def _ddcontext_provider(self):

releasenotes/notes/fix-otel-span-context-d5c9d1ec46cf7941.yaml

@@ -0,0 +1,5 @@
+---
+features:
+  - |
+    opentelemetry: Added support for nested context activation and deactivation using ``attach()`` and ``detach()`` from the OpenTelemetry context API. Deactivating a context properly restores the previous active trace.
+    Note: ``detach()`` only supports deactivating the last active trace and baggage. Other signals present in the context will not be restored.

tests/opentelemetry/test_context.py

@@ -2,10 +2,15 @@
 import time
 
 import opentelemetry
+from opentelemetry import context as context_api
 from opentelemetry.baggage import get_baggage
 from opentelemetry.baggage import remove_baggage
 from opentelemetry.baggage import set_baggage
+from opentelemetry.context import Context
 from opentelemetry.context import attach
+from opentelemetry.trace import get_current_span
+from opentelemetry.trace import set_span_in_context
+from opentelemetry.trace.span import INVALID_SPAN
 import pytest
 
 import ddtrace
@@ -229,3 +234,39 @@ def test_providers_are_set():
     assert tracer_provider.get_tracer(__name__) is not None
     assert meter_provider.get_meter(__name__) is not None
     assert logger_provider.get_logger(__name__) is not None
+
+
+def test_otel_context_api(oteltracer):
+    """Validates context activation and deactivation using the OpenTelemetry context API."""
+    # Verify test starts with clean context
+    assert get_current_span() is INVALID_SPAN
+
+    try:
+        # Attach span1 and verify it becomes active
+        span1 = oteltracer.start_span("span1")
+        token1 = context_api.attach(set_span_in_context(span1))
+        assert get_current_span()._ddspan == span1._ddspan
+        # Attach span2 and verify it becomes active (nested)
+        span2 = oteltracer.start_span("span2")
+        token2 = context_api.attach(set_span_in_context(span2))
+        assert get_current_span()._ddspan == span2._ddspan
+        # Attach span3 and verify it becomes active (double-nested)
+        span3 = oteltracer.start_span("span3")
+        token3 = context_api.attach(set_span_in_context(span3))
+        assert get_current_span()._ddspan == span3._ddspan
+        # Detach span3, span2 should become active again
+        context_api.detach(token3)
+        assert get_current_span()._ddspan == span2._ddspan
+        # Detach span2, span1 should become active again
+        context_api.detach(token2)
+        assert get_current_span()._ddspan == span1._ddspan
+        # Detach span1, no active span should remain
+        context_api.detach(token1)
+        assert get_current_span() is INVALID_SPAN
+        # End spans to clean up
+        span1.end()
+        span2.end()
+        span3.end()
+    finally:
+        # Clear context to prevent leaking spans to subsequent tests
+        context_api.attach(Context())

tests/tracer/test_tracer.py

@@ -2042,3 +2042,38 @@ def test_activate_context_nesting_and_restoration(tracer):
         assert active.span_id == 1
 
     assert tracer.context_provider.active() is None
+
+
+def test_activate_and_deactivate_active_trace(tracer):
+    """Test that deactivating an active trace properly restores the previous active trace."""
+    # Verify test starts with clean context
+    assert tracer.context_provider.active() is None
+
+    try:
+        # Activate span1 and verify it becomes active
+        span1 = tracer.start_span("span1")
+        token1 = tracer.context_provider.activate(span1)
+        assert tracer.context_provider.active() == span1
+        # Activate span2 and verify it becomes active (nested)
+        span2 = tracer.start_span("span2")
+        token2 = tracer.context_provider.activate(span2)
+        assert tracer.context_provider.active() == span2
+        # Activate a context and verify it becomes active (double-nested)
+        context3 = Context(trace_id=3, span_id=3)
+        token3 = tracer.context_provider.activate(context3)
+        assert tracer.context_provider.active() == context3
+        # Deactivate span3, span2 should become active again
+        tracer.context_provider._deactivate(token3)
+        assert tracer.context_provider.active() == span2
+        # Deactivate span2, span1 should become active again
+        tracer.context_provider._deactivate(token2)
+        assert tracer.context_provider.active() == span1
+        # Deactivate span1, no active span should remain
+        tracer.context_provider._deactivate(token1)
+        assert tracer.context_provider.active() is None
+        # End spans to clean up
+        span1.finish()
+        span2.finish()
+    finally:
+        # Clear context to prevent leaking spans to subsequent tests
+        tracer.context_provider.activate(None)