ref: Don't auto-promote child spans to segments in integrations in span streaming

sentry_sdk/integrations/aiohttp.py

@@ -351,8 +351,12 @@ async def on_request_start(
             parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE,
         )
 
-        span: "Union[Span, StreamedSpan]"
+        span: "Union[Span, StreamedSpan, None]"
         if has_span_streaming_enabled(client.options):
+            if sentry_sdk.traces.get_current_span() is None:
+                trace_config_ctx.span = None
+                return
+
             attributes: "Attributes" = {
                 "sentry.op": OP.HTTP_CLIENT,
                 "sentry.origin": AioHttpIntegration.origin,

sentry_sdk/integrations/aiomysql.py

@@ -179,33 +179,34 @@ async def _inner(self: "Connection") -> T:
                 "sentry.origin": AioMySQLIntegration.origin,
             } | breadcrumb_data
 
+            if sentry_sdk.traces.get_current_span() is None:
+                return await f(self)
+
             with sentry_sdk.traces.start_span(
                 name="connect", attributes=span_attributes
-            ) as span:
+            ):
                 with capture_internal_exceptions():
                     sentry_sdk.add_breadcrumb(
                         message="connect", category="query", data=breadcrumb_data
                     )
-                res = await f(self)
-        else:
-            connect_data = _get_connect_data(self)
-
-            with sentry_sdk.start_span(
-                op=OP.DB,
-                name="connect",
-                origin=AioMySQLIntegration.origin,
-            ) as span:
-                _set_db_data(span, self)
+                return await f(self)
 
-                with capture_internal_exceptions():
-                    sentry_sdk.add_breadcrumb(
-                        message="connect",
-                        category="query",
-                        data=connect_data,
-                    )
-                res = await f(self)
+        connect_data = _get_connect_data(self)
 
-        return res
+        with sentry_sdk.start_span(
+            op=OP.DB,
+            name="connect",
+            origin=AioMySQLIntegration.origin,
+        ) as span:
+            _set_db_data(span, self)
+
+            with capture_internal_exceptions():
+                sentry_sdk.add_breadcrumb(
+                    message="connect",
+                    category="query",
+                    data=connect_data,
+                )
+            return await f(self)
 
     return _inner
 

sentry_sdk/integrations/anthropic.py

@@ -640,6 +640,8 @@ def _sentry_patched_create_sync(f: "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 f(*args, **kwargs)
         span = sentry_sdk.traces.start_span(
             name=f"chat {model}".strip(),
             attributes={
@@ -738,6 +740,8 @@ async def _sentry_patched_create_async(
 
     span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
     if span_streaming:
+        if sentry_sdk.traces.get_current_span() is None:
+            return await f(*args, **kwargs)
         span = sentry_sdk.traces.start_span(
             name=f"chat {model}".strip(),
             attributes={
@@ -982,6 +986,8 @@ def _sentry_patched_enter(self: "MessageStreamManager") -> "MessageStream":
             return f(self)
 
         if has_span_streaming_enabled(client.options):
+            if sentry_sdk.traces.get_current_span() is None:
+                return f(self)
             span = sentry_sdk.traces.start_span(
                 name="chat" if self._model is None else f"chat {self._model}".strip(),
                 attributes={
@@ -1089,6 +1095,8 @@ async def _sentry_patched_aenter(
             return await f(self)
 
         if has_span_streaming_enabled(client.options):
+            if sentry_sdk.traces.get_current_span() is None:
+                return await f(self)
             span = sentry_sdk.traces.start_span(
                 name="chat" if self._model is None else f"chat {self._model}".strip(),
                 attributes={

sentry_sdk/integrations/arq.py

@@ -79,6 +79,9 @@ async def _sentry_enqueue_job(
             return await old_enqueue_job(self, function, *args, **kwargs)
 
         if has_span_streaming_enabled(client.options):
+            if sentry_sdk.traces.get_current_span() is None:
+                return await old_enqueue_job(self, function, *args, **kwargs)
+
             with sentry_sdk.traces.start_span(
                 name=function,
                 attributes={

sentry_sdk/integrations/asyncio.py

@@ -155,13 +155,14 @@ async def _task_with_sentry_span_creation() -> "Any":
                 with sentry_sdk.isolation_scope():
                     if task_spans:
                         if is_span_streaming_enabled:
-                            span_ctx = sentry_sdk.traces.start_span(
-                                name=get_name(coro),
-                                attributes={
-                                    "sentry.op": OP.FUNCTION,
-                                    "sentry.origin": AsyncioIntegration.origin,
-                                },
-                            )
+                            if sentry_sdk.traces.get_current_span() is not None:
+                                span_ctx = sentry_sdk.traces.start_span(
+                                    name=get_name(coro),
+                                    attributes={
+                                        "sentry.op": OP.FUNCTION,
+                                        "sentry.origin": AsyncioIntegration.origin,
+                                    },
+                                )
                         else:
                             span_ctx = sentry_sdk.start_span(
                                 op=OP.FUNCTION,

sentry_sdk/integrations/asyncpg.py

@@ -235,39 +235,39 @@ async def _inner(*args: "Any", **kwargs: "Any") -> "T":
                 except IndexError:
                     pass
 
+            if sentry_sdk.traces.get_current_span() is None:
+                return await f(*args, **kwargs)
+
             with sentry_sdk.traces.start_span(
                 name="connect", attributes=span_attributes
-            ) as span:
+            ):
                 with capture_internal_exceptions():
                     sentry_sdk.add_breadcrumb(
                         message="connect", category="query", data=span_attributes
                     )
-                res = await f(*args, **kwargs)
-
-        else:
-            with sentry_sdk.start_span(
-                op=OP.DB,
-                name="connect",
-                origin=AsyncPGIntegration.origin,
-            ) as span:
-                span.set_data(SPANDATA.DB_SYSTEM, "postgresql")
-                if addr:
-                    try:
-                        span.set_data(SPANDATA.SERVER_ADDRESS, addr[0])
-                        span.set_data(SPANDATA.SERVER_PORT, addr[1])
-                    except IndexError:
-                        pass
-                span.set_data(SPANDATA.DB_NAME, database)
-                span.set_data(SPANDATA.DB_USER, user)
-                span.set_data(SPANDATA.DB_DRIVER_NAME, "asyncpg")
+                return await f(*args, **kwargs)
 
-                with capture_internal_exceptions():
-                    sentry_sdk.add_breadcrumb(
-                        message="connect", category="query", data=span._data
-                    )
-                res = await f(*args, **kwargs)
+        with sentry_sdk.start_span(
+            op=OP.DB,
+            name="connect",
+            origin=AsyncPGIntegration.origin,
+        ) as span:
+            span.set_data(SPANDATA.DB_SYSTEM, "postgresql")
+            if addr:
+                try:
+                    span.set_data(SPANDATA.SERVER_ADDRESS, addr[0])
+                    span.set_data(SPANDATA.SERVER_PORT, addr[1])
+                except IndexError:
+                    pass
+            span.set_data(SPANDATA.DB_NAME, database)
+            span.set_data(SPANDATA.DB_USER, user)
+            span.set_data(SPANDATA.DB_DRIVER_NAME, "asyncpg")
 
-        return res
+            with capture_internal_exceptions():
+                sentry_sdk.add_breadcrumb(
+                    message="connect", category="query", data=span._data
+                )
+            return await f(*args, **kwargs)
 
     return _inner
 

sentry_sdk/integrations/boto3.py

@@ -67,6 +67,8 @@ def _sentry_request_created(
     is_span_streaming_enabled = has_span_streaming_enabled(client.options)
     span: "Union[Span, StreamedSpan]"
     if is_span_streaming_enabled:
+        if sentry_sdk.traces.get_current_span() is None:
+            return
         span = sentry_sdk.traces.start_span(
             name=description,
             attributes={

sentry_sdk/integrations/celery/__init__.py

@@ -419,6 +419,9 @@ def _inner(*args: "Any", **kwargs: "Any") -> "Any":
         span_streaming = has_span_streaming_enabled(client.options)
 
         try:
+            if span_streaming and get_current_span() is None:
+                return f(*args, **kwargs)
+
             span: "Union[Span, StreamedSpan]"
             if span_streaming:
                 span = sentry_sdk.traces.start_span(
@@ -462,7 +465,8 @@ def _inner(*args: "Any", **kwargs: "Any") -> "Any":
 
                 with capture_internal_exceptions():
                     set_on_span(
-                        SPANDATA.MESSAGING_MESSAGE_RETRY_COUNT, task.request.retries
+                        SPANDATA.MESSAGING_MESSAGE_RETRY_COUNT,
+                        task.request.retries,
                     )
 
                 with capture_internal_exceptions():

sentry_sdk/integrations/clickhouse_driver.py

@@ -85,14 +85,16 @@ def _inner(*args: "P.args", **kwargs: "P.kwargs") -> "T":
         params = args[3] if len(args) > 3 else kwargs.get("params")
 
         if has_span_streaming_enabled(client.options):
-            span = sentry_sdk.traces.start_span(
-                name=query,  # type: ignore
-                attributes={
-                    "sentry.op": OP.DB,
-                    "sentry.origin": ClickhouseDriverIntegration.origin,
-                    SPANDATA.DB_QUERY_TEXT: str(query),
-                },
-            )
+            span = None
+            if sentry_sdk.traces.get_current_span() is not None:
+                span = sentry_sdk.traces.start_span(
+                    name=query,  # type: ignore
+                    attributes={
+                        "sentry.op": OP.DB,
+                        "sentry.origin": ClickhouseDriverIntegration.origin,
+                        SPANDATA.DB_QUERY_TEXT: str(query),
+                    },
+                )
         else:
             span = sentry_sdk.start_span(
                 op=OP.DB,
@@ -110,7 +112,8 @@ def _inner(*args: "P.args", **kwargs: "P.kwargs") -> "T":
 
         connection._sentry_span = span  # type: ignore[attr-defined]
 
-        _set_db_data(span, connection)
+        if span is not None:
+            _set_db_data(span, connection)
 
         # run the original code
         ret = f(*args, **kwargs)

sentry_sdk/integrations/cohere.py

@@ -17,7 +17,11 @@
 import sentry_sdk
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.utils import capture_internal_exceptions, event_from_exception, reraise
+from sentry_sdk.utils import (
+    capture_internal_exceptions,
+    event_from_exception,
+    reraise,
+)
 
 try:
     from cohere import (
@@ -154,6 +158,8 @@ def new_chat(*args: "Any", **kwargs: "Any") -> "Any":
         message = kwargs.get("message")
 
         if is_span_streaming_enabled:
+            if sentry_sdk.traces.get_current_span() is None:
+                return f(*args, **kwargs)
             span = sentry_sdk.traces.start_span(
                 name="cohere.client.Chat",
                 attributes={
@@ -250,6 +256,8 @@ def new_embed(*args: "Any", **kwargs: "Any") -> "Any":
         )
 
         if is_span_streaming_enabled:
+            if sentry_sdk.traces.get_current_span() is None:
+                return f(*args, **kwargs)
             span_ctx = sentry_sdk.traces.start_span(
                 name="Cohere Embedding Creation",
                 attributes={

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={

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={

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={

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={

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(

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={