Merge branch 'ivana/streaming-child-spans-web-frameworks' of github.com:getsentry/sentry-python into ivana/streaming-child-spans-web-frameworks

ericapisani · ericapisani · commit 2b6ba2ddd05d · 2026-07-15T10:50:16.000-04:00
diff --git a/sentry_sdk/client.py b/sentry_sdk/client.py
@@ -382,6 +382,12 @@ def _get_options(*args: "Optional[str]", **kwargs: "Any") -> "Dict[str, Any]":
             stacklevel=2,
         )
 
+    if rv["ignore_spans"] and not has_span_streaming_enabled(rv):
+        warnings.warn(
+            "The `ignore_spans` parameter only works when `trace_lifecycle` is set to `stream`.",
+            stacklevel=2,
+        )
+
     return rv
 
 
diff --git a/sentry_sdk/consts.py b/sentry_sdk/consts.py
@@ -1272,6 +1272,7 @@ def __init__(
         server_name: "Optional[str]" = None,
         shutdown_timeout: float = 2,
         integrations: "Sequence[sentry_sdk.integrations.Integration]" = [],  # noqa: B006
+        ignore_spans: "Optional[IgnoreSpansConfig]" = None,
         in_app_include: "List[str]" = [],  # noqa: B006
         in_app_exclude: "List[str]" = [],  # noqa: B006
         default_integrations: bool = True,
@@ -1293,6 +1294,7 @@ def __init__(
         ca_certs: "Optional[str]" = None,
         propagate_traces: bool = True,
         traces_sample_rate: "Optional[float]" = None,
+        trace_lifecycle: "Optional[Literal['static', 'stream']]" = None,
         traces_sampler: "Optional[TracesSampler]" = None,
         profiles_sample_rate: "Optional[float]" = None,
         profiles_sampler: "Optional[TracesSampler]" = None,
@@ -1757,6 +1759,12 @@ def __init__(
         :param stream_gen_ai_spans: When set, generative AI spans are sent in a new transport format to
             reduce downstream data loss.
 
+        :param trace_lifecycle: Controls how traces are sent. Set to `"stream"` to send spans as they
+            finish, or `"static"` to send a completed trace as a transaction event.
+
+        :param ignore_spans: A sequence of span-matching rules. Matching spans are ignored when
+            `trace_lifecycle="stream"` is enabled.
+
         :param _experiments: Dictionary of experimental, opt-in features that are not yet stable.
 
             ``data_collection`` (EXPERIMENTAL): structured configuration controlling what data integrations
diff --git a/sentry_sdk/integrations/django/__init__.py b/sentry_sdk/integrations/django/__init__.py
@@ -724,6 +724,8 @@ def connect(self: "BaseDatabaseWrapper") -> None:
 
         span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return real_connect(self)
             with sentry_sdk.traces.start_span(
                 name="connect",
                 attributes={
@@ -750,6 +752,8 @@ def _commit(self: "BaseDatabaseWrapper") -> None:
 
         span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return real_commit(self)
             with sentry_sdk.traces.start_span(
                 name=SPANNAME.DB_COMMIT,
                 attributes={
@@ -776,6 +780,8 @@ def _rollback(self: "BaseDatabaseWrapper") -> None:
 
         span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return real_rollback(self)
             with sentry_sdk.traces.start_span(
                 name=SPANNAME.DB_ROLLBACK,
                 attributes={
diff --git a/sentry_sdk/integrations/django/asgi.py b/sentry_sdk/integrations/django/asgi.py
@@ -191,6 +191,8 @@ async def sentry_wrapped_callback(
             return await callback(request, *args, **kwargs)
 
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return await callback(request, *args, **kwargs)
             with sentry_sdk.traces.start_span(
                 name=request.resolver_match.view_name,
                 attributes={
diff --git a/sentry_sdk/integrations/django/caching.py b/sentry_sdk/integrations/django/caching.py
@@ -61,6 +61,8 @@ def _instrument_call(
 
         span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return original_method(*args, **kwargs)
             with sentry_sdk.traces.start_span(
                 name=description,
                 attributes={
diff --git a/sentry_sdk/integrations/django/middleware.py b/sentry_sdk/integrations/django/middleware.py
@@ -84,6 +84,8 @@ def _check_middleware_span(
         span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
         middleware_span: "Union[Span, StreamedSpan]"
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return None
             middleware_span = sentry_sdk.traces.start_span(
                 name=description,
                 attributes={
diff --git a/sentry_sdk/integrations/django/signals_handlers.py b/sentry_sdk/integrations/django/signals_handlers.py
@@ -68,14 +68,16 @@ def wrapper(*args: "Any", **kwargs: "Any") -> "Any":
                     sentry_sdk.get_client().options
                 )
                 if span_streaming:
+                    if sentry_sdk.traces.get_current_span() is None:
+                        return receiver(*args, **kwargs)
                     with sentry_sdk.traces.start_span(
                         name=signal_name,
                         attributes={
                             "sentry.op": OP.EVENT_DJANGO,
                             "sentry.origin": DjangoIntegration.origin,
                             SPANDATA.CODE_FUNCTION_NAME: signal_name,
                         },
-                    ) as span:
+                    ):
                         return receiver(*args, **kwargs)
                 else:
                     with sentry_sdk.start_span(
diff --git a/sentry_sdk/integrations/django/tasks.py b/sentry_sdk/integrations/django/tasks.py
@@ -35,6 +35,8 @@ def _sentry_enqueue(self: "Any", *args: "Any", **kwargs: "Any") -> "Any":
 
         span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return old_task_enqueue(self, *args, **kwargs)
             with sentry_sdk.traces.start_span(
                 name=name,
                 attributes={
diff --git a/sentry_sdk/integrations/django/templates.py b/sentry_sdk/integrations/django/templates.py
@@ -64,13 +64,15 @@ def patch_templates() -> None:
     def rendered_content(self: "SimpleTemplateResponse") -> str:
         span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return real_rendered_content.fget(self)
             with sentry_sdk.traces.start_span(
                 name=_get_template_name_description(self.template_name),
                 attributes={
                     "sentry.op": OP.TEMPLATE_RENDER,
                     "sentry.origin": DjangoIntegration.origin,
                 },
-            ) as span:
+            ):
                 return real_rendered_content.fget(self)
         else:
             with sentry_sdk.start_span(
@@ -109,13 +111,15 @@ def render(
         span_streaming = has_span_streaming_enabled(client.options)
 
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return real_render(request, template_name, context, *args, **kwargs)
             with sentry_sdk.traces.start_span(
                 name=_get_template_name_description(template_name),
                 attributes={
                     "sentry.op": OP.TEMPLATE_RENDER,
                     "sentry.origin": DjangoIntegration.origin,
                 },
-            ) as span:
+            ):
                 return real_render(request, template_name, context, *args, **kwargs)
         else:
             with sentry_sdk.start_span(
diff --git a/sentry_sdk/integrations/django/views.py b/sentry_sdk/integrations/django/views.py
@@ -34,6 +34,8 @@ def patch_views() -> None:
     def sentry_patched_render(self: "SimpleTemplateResponse") -> "Any":
         span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return old_render(self)
             with sentry_sdk.traces.start_span(
                 name="serialize response",
                 attributes={
@@ -108,6 +110,8 @@ def sentry_wrapped_callback(request: "Any", *args: "Any", **kwargs: "Any") -> "A
             return callback(request, *args, **kwargs)
 
         if span_streaming:
+            if sentry_sdk.traces.get_current_span() is None:
+                return callback(request, *args, **kwargs)
             with sentry_sdk.traces.start_span(
                 name=request.resolver_match.view_name,
                 attributes={
diff --git a/sentry_sdk/traces.py b/sentry_sdk/traces.py
@@ -4,7 +4,7 @@
 The API in this file is only meant to be used in span streaming mode.
 
 You can enable span streaming mode via
-sentry_sdk.init(_experiments={"trace_lifecycle": "stream"}).
+sentry_sdk.init(trace_lifecycle="stream").
 """
 
 import sys
@@ -854,7 +854,7 @@ def get_current_span(
     Returns the currently active span on the scope if the span is a `StreamedSpan`, otherwise `None`.
 
     This function will only return a non-`None` value when the streaming trace lifecycle is enabled.
-    To enable the lifecycle, pass `_experiments={"trace_lifecycle": "stream"}` to `sentry.init()`.
+    To enable the lifecycle, pass `trace_lifecycle="stream"` to `sentry.init()`.
     """
     scope = scope or sentry_sdk.get_current_scope()
     current_span = scope.streamed_span
diff --git a/sentry_sdk/tracing_utils.py b/sentry_sdk/tracing_utils.py
@@ -113,7 +113,14 @@ def has_span_streaming_enabled(options: "Optional[dict[str, Any]]") -> bool:
     if options is None:
         return False
 
-    return (options.get("_experiments") or {}).get("trace_lifecycle") == "stream"
+    is_enabled_in_experiment_config = (options.get("_experiments") or {}).get(
+        "trace_lifecycle"
+    ) == "stream"
+
+    if options.get("trace_lifecycle") is not None:
+        return options.get("trace_lifecycle") == "stream"
+
+    return is_enabled_in_experiment_config
 
 
 def should_truncate_gen_ai_input(options: "Optional[dict[str, Any]]") -> bool:
@@ -1647,7 +1654,16 @@ def _make_sampling_decision(
 def is_ignored_span(name: str, attributes: "Optional[Attributes]") -> bool:
     """Determine if a span fits one of the rules in ignore_spans."""
     client = sentry_sdk.get_client()
-    ignore_spans = (client.options.get("_experiments") or {}).get("ignore_spans")
+    is_ignored_at_top_level = client.options.get("ignore_spans", None)
+    is_ignored_in_experiment_config = (client.options.get("_experiments") or {}).get(
+        "ignore_spans"
+    )
+
+    ignore_spans = (
+        is_ignored_at_top_level
+        if is_ignored_at_top_level is not None
+        else is_ignored_in_experiment_config
+    )
 
     if not ignore_spans:
         return False
diff --git a/tests/integrations/django/asgi/test_asgi.py b/tests/integrations/django/asgi/test_asgi.py
@@ -1027,8 +1027,8 @@ async def test_transaction_http_method_custom(
         sentry_sdk.flush()
         spans = [item.payload for item in items]
 
-        assert spans[10]["attributes"][SPANDATA.HTTP_REQUEST_METHOD] == "OPTIONS"
-        assert spans[16]["attributes"][SPANDATA.HTTP_REQUEST_METHOD] == "HEAD"
+        assert spans[5]["attributes"][SPANDATA.HTTP_REQUEST_METHOD] == "OPTIONS"
+        assert spans[11]["attributes"][SPANDATA.HTTP_REQUEST_METHOD] == "HEAD"
     else:
         events = capture_events()
 
diff --git a/tests/integrations/django/test_basic.py b/tests/integrations/django/test_basic.py
@@ -2370,8 +2370,8 @@ def test_transaction_http_method_custom(
         sentry_sdk.flush()
         spans = [item.payload for item in items]
 
-        assert spans[4]["attributes"][SPANDATA.HTTP_REQUEST_METHOD] == "OPTIONS"
-        assert spans[7]["attributes"][SPANDATA.HTTP_REQUEST_METHOD] == "HEAD"
+        assert spans[2]["attributes"][SPANDATA.HTTP_REQUEST_METHOD] == "OPTIONS"
+        assert spans[5]["attributes"][SPANDATA.HTTP_REQUEST_METHOD] == "HEAD"
     else:
         events = capture_events()
 
diff --git a/tests/integrations/logging/test_logging.py b/tests/integrations/logging/test_logging.py
@@ -223,9 +223,12 @@ def test_logging_captured_warnings(sentry_init, capture_events, recwarn):
     assert events[1]["logentry"]["message"] == events[1]["logentry"]["formatted"]
     assert events[1]["logentry"]["params"] == []
 
-    # Using recwarn suppresses the "third" warning in the test output
-    assert len(recwarn) == 1
-    assert str(recwarn[0].message) == "third"
+    # "third" is emitted after captureWarnings(False), so it is not captured
+    # by Sentry and instead surfaces as a normal warning. Using recwarn also
+    # suppresses it in the test output. Filter by message rather than asserting
+    # on the total count, since unrelated warnings from other tests can leak in.
+    third_warnings = [w for w in recwarn if str(w.message) == "third"]
+    assert len(third_warnings) == 1
 
 
 def test_ignore_logger(sentry_init, capture_events, request):
diff --git a/tests/test_client.py b/tests/test_client.py
@@ -4,6 +4,7 @@
 import subprocess
 import sys
 import time
+import warnings
 from collections import Counter, defaultdict
 from collections.abc import Mapping
 from textwrap import dedent
@@ -1524,6 +1525,28 @@ def test_enable_tracing_deprecated(sentry_init, enable_tracing):
         sentry_init(enable_tracing=enable_tracing)
 
 
+def test_ignore_spans_warns_without_streaming(sentry_init):
+    with pytest.warns(UserWarning, match=r"`ignore_spans` parameter only works"):
+        sentry_init(ignore_spans=["/health"], trace_lifecycle="static")
+
+
+@pytest.mark.parametrize(
+    "options",
+    [
+        {"ignore_spans": ["/health"], "trace_lifecycle": "stream"},
+        {"ignore_spans": ["/health"], "_experiments": {"trace_lifecycle": "stream"}},
+        {},
+    ],
+)
+def test_ignore_spans_does_not_warn(sentry_init, options):
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        sentry_init(**options)
+
+    ignore_spans_warnings = [w for w in caught if "ignore_spans" in str(w.message)]
+    assert ignore_spans_warnings == []
+
+
 def make_options_transport_cls():
     """Make an options transport class that captures the options passed to it."""
     # We need a unique class for each test so that the options are not
diff --git a/tests/test_serializer.py b/tests/test_serializer.py
@@ -1,4 +1,3 @@
-import gc
 import re
 from array import array
 
@@ -184,29 +183,6 @@ def test_max_value_length(body_normalizer):
     assert len(result["key"]) == max_value_length
 
 
-def test_serialize_does_not_leave_cyclic_garbage():
-    # Applications running with the GC disabled rely on serialize() being
-    # freed by reference counting alone, so it must not create reference
-    # cycles.
-    gc_was_enabled = gc.isenabled()
-    old_debug_flags = gc.get_debug()
-    gc.collect()
-    gc.disable()
-    try:
-        serialize({"extra": {"foo": [{"bar": i} for i in range(20)]}})
-        serialize({"foo": "bar"}, is_vars=True)
-
-        gc.set_debug(gc.DEBUG_SAVEALL)
-        gc.collect()
-        assert gc.garbage == []
-    finally:
-        gc.set_debug(old_debug_flags)
-        gc.garbage.clear()
-        gc.collect()
-        if gc_was_enabled:
-            gc.enable()
-
-
 def test_serialize_local_vars():
     # This was added to make sure we don't try to iterate over instances of
     # custom classes with an __iter__ method due to potential side effects
diff --git a/tests/tracing/test_span_streaming.py b/tests/tracing/test_span_streaming.py
