Patch TracerProvider if it already exists (#4455)

If a `TracerProvider` already exists, patch it. `TracerProvider` is a
singleton, so if we aren't the first ones setting it up, we need to use
the existing one.

In tests, reset `TracerProvider` after each test so that we start with a
clean slate and it gets set up anew on init.

Author: sentrivana

sentry_sdk/opentelemetry/propagator.py

@@ -20,7 +20,9 @@
     SpanContext,
     TraceFlags,
 )
+from opentelemetry.semconv.trace import SpanAttributes
 
+import sentry_sdk
 from sentry_sdk.consts import (
     BAGGAGE_HEADER_NAME,
     SENTRY_TRACE_HEADER_NAME,
@@ -30,7 +32,11 @@
     SENTRY_TRACE_KEY,
     SENTRY_SCOPES_KEY,
 )
-from sentry_sdk.tracing_utils import Baggage, extract_sentrytrace_data
+from sentry_sdk.tracing_utils import (
+    Baggage,
+    extract_sentrytrace_data,
+    should_propagate_trace,
+)
 
 from typing import TYPE_CHECKING
 
@@ -89,18 +95,21 @@ def extract(self, carrier, context=None, getter=default_getter):
 
     def inject(self, carrier, context=None, setter=default_setter):
         # type: (CarrierT, Optional[Context], Setter[CarrierT]) -> None
-        if context is None:
-            context = get_current()
-
         scopes = get_value(SENTRY_SCOPES_KEY, context)
-        if scopes:
-            scopes = cast("tuple[scope.PotelScope, scope.PotelScope]", scopes)
-            (current_scope, _) = scopes
-
-            # TODO-neel-potel check trace_propagation_targets
-            # TODO-neel-potel test propagator works with twp
-            for key, value in current_scope.iter_trace_propagation_headers():
-                setter.set(carrier, key, value)
+        if not scopes:
+            return
+
+        scopes = cast("tuple[scope.PotelScope, scope.PotelScope]", scopes)
+        (current_scope, _) = scopes
+
+        span = current_scope.span
+        if span:
+            span_url = span.get_attribute(SpanAttributes.HTTP_URL)
+            if span_url and not should_propagate_trace(sentry_sdk.get_client(), span_url):
+                return
+
+        for key, value in current_scope.iter_trace_propagation_headers():
+            setter.set(carrier, key, value)
 
     @property
     def fields(self):

sentry_sdk/opentelemetry/tracing.py

@@ -7,6 +7,7 @@
     SentrySampler,
     SentrySpanProcessor,
 )
+from sentry_sdk.utils import logger
 
 
 def patch_readable_span():
@@ -28,8 +29,31 @@ def sentry_patched_readable_span(self):
 
 def setup_sentry_tracing():
     # type: () -> None
-    provider = TracerProvider(sampler=SentrySampler())
-    provider.add_span_processor(SentrySpanProcessor())
-    trace.set_tracer_provider(provider)
+    # TracerProvider can only be set once. If we're the first ones setting it,
+    # there's no issue. If it already exists, we need to patch it.
+    from opentelemetry.trace import _TRACER_PROVIDER
+
+    if _TRACER_PROVIDER is not None:
+        logger.debug("[Tracing] Detected an existing TracerProvider, patching")
+        tracer_provider = _TRACER_PROVIDER
+        tracer_provider.sampler = SentrySampler()  # type: ignore[attr-defined]
+
+    else:
+        logger.debug("[Tracing] No TracerProvider set, creating a new one")
+        tracer_provider = TracerProvider(sampler=SentrySampler())
+        trace.set_tracer_provider(tracer_provider)
+
+    try:
+        existing_span_processors = (
+            tracer_provider._active_span_processor._span_processors  # type: ignore[attr-defined]
+        )
+    except Exception:
+        existing_span_processors = []
+
+    for span_processor in existing_span_processors:
+        if isinstance(span_processor, SentrySpanProcessor):
+            break
+    else:
+        tracer_provider.add_span_processor(SentrySpanProcessor())  # type: ignore[attr-defined]
 
     set_global_textmap(SentryPropagator())

sentry_sdk/tracing.py

@@ -188,7 +188,7 @@ def __init__(
         If otel_span is passed explicitly, just acts as a proxy.
 
         If span is passed explicitly, use it. The only purpose of this param
-        if backwards compatibility with start_transaction(transaction=...).
+        is backwards compatibility with start_transaction(transaction=...).
 
         If only_if_parent is True, just return an INVALID_SPAN
         and avoid instrumentation if there's no active parent span.

tests/conftest.py

@@ -2,6 +2,12 @@
 import os
 import socket
 import warnings
+from opentelemetry import trace as otel_trace
+
+try:
+    from opentelemetry.util._once import Once
+except ImportError:
+    Once = None
 from threading import Thread
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
@@ -73,6 +79,14 @@ def clean_scopes():
     setup_initial_scopes()
 
 
+@pytest.fixture(autouse=True)
+def clear_tracer_provider():
+    """Reset TracerProvider so that we can set it up from scratch."""
+    if Once is not None:
+        otel_trace._TRACER_PROVIDER_SET_ONCE = Once()
+    otel_trace._TRACER_PROVIDER = None
+
+
 @pytest.fixture(autouse=True)
 def internal_exceptions(request):
     errors = []

tests/opentelemetry/test_propagator.py

@@ -4,11 +4,16 @@
 
 from opentelemetry.trace.propagation import get_current_span
 from opentelemetry.propagators.textmap import DefaultSetter
+from opentelemetry.semconv.trace import SpanAttributes
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.trace import SpanKind
 
 import sentry_sdk
+from sentry_sdk.consts import MATCH_ALL
 from sentry_sdk.opentelemetry.consts import (
     SENTRY_BAGGAGE_KEY,
     SENTRY_TRACE_KEY,
+    SENTRY_SCOPES_KEY,
 )
 from sentry_sdk.opentelemetry import SentryPropagator
 from tests.conftest import SortedBaggage
@@ -208,3 +213,67 @@ def test_inject_head_sdk(sentry_init):
             assert carrier["baggage"] == SortedBaggage(
                 expected_baggage.format(trace_id=span.trace_id)
             )
+
+
+@pytest.mark.parametrize(
+    "trace_propagation_targets,url,trace_propagated",
+    [
+        # No targets - should not propagate
+        ([], "https://example.com/api/users", False),
+        (None, "https://example.com/api/users", False),
+        # MATCH_ALL - should propagate
+        ([MATCH_ALL], "https://example.com/api/users", True),
+        # Exact match - should propagate
+        (["https://example.com"], "https://example.com/api/users", True),
+        (["https://example.com/"], "https://example.com/api/users", True),
+        # No match - should not propagate
+        (["https://example.com"], "https://other-domain.com/api/users", False),
+        (["https://example.com/"], "https://other-domain.com/api/users", False),
+        # Regex patterns
+        (
+            ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+            "https://good.example.net/api",
+            True,
+        ),
+        (
+            ["https://example.com", r"https?:\/\/[\w\-]+(\.[\w\-]+)+\.net"],
+            "https://example.net/api",
+            False,
+        ),
+        # HTTP vs HTTPS
+        (["https://example.com"], "http://example.com/api/users", False),
+        (["http://example.com"], "https://example.com/api/users", False),
+        # Path matching
+        (["https://example.com/api"], "https://example.com/api/users", True),
+        (["https://example.com/api"], "https://example.com/other/path", False),
+    ],
+)
+def test_propagator_trace_propagation_targets(
+    sentry_init,
+    trace_propagation_targets,
+    url,
+    trace_propagated,
+):
+    """Test that the propagator respects trace_propagation_targets for HTTP spans."""
+    sentry_init(
+        trace_propagation_targets=trace_propagation_targets,
+        traces_sample_rate=1.0,
+    )
+
+    carrier = {}
+    setter = DefaultSetter()
+
+    # Create a real HTTP span with the test URL
+    with sentry_sdk.start_span(name="http.client") as span:
+        span.set_attribute(SpanAttributes.HTTP_METHOD, "GET")
+        span.set_attribute(SpanAttributes.HTTP_URL, url)
+
+        # Test the propagator
+        SentryPropagator().inject(carrier, setter=setter)
+
+        if trace_propagated:
+            assert "sentry-trace" in carrier
+            assert "baggage" in carrier
+        else:
+            assert "sentry-trace" not in carrier
+            assert "baggage" not in carrier