ref(asyncio): Migrate integration to span-first

Update the asyncio integration to use sentry_sdk.traces.start_span()
when span streaming is enabled, storing op and origin as span
attributes instead of top-level fields.

Add span_streaming parametrization to test_create_task to cover both
the legacy static path and the new streaming path, asserting on
segment and span structure in each mode.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: ericapisani

sentry_sdk/integrations/asyncio.py

@@ -1,17 +1,18 @@
-import sys
 import functools
+import sys
 
 import sentry_sdk
 from sentry_sdk.consts import OP
-from sentry_sdk.integrations import Integration, DidNotEnable
+from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.integrations._wsgi_common import nullcontext
+from sentry_sdk.tracing_utils import has_span_streaming_enabled
+from sentry_sdk.transport import AsyncHttpTransport
 from sentry_sdk.utils import (
     event_from_exception,
+    is_internal_task,
     logger,
     reraise,
-    is_internal_task,
 )
-from sentry_sdk.transport import AsyncHttpTransport
 
 try:
     import asyncio
@@ -22,8 +23,8 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, TypeVar
     from collections.abc import Coroutine
+    from typing import Any, Callable, TypeVar
 
     from sentry_sdk._types import ExcInfo
 
@@ -142,22 +143,31 @@ def _sentry_task_factory(
             @_wrap_coroutine(coro)
             async def _task_with_sentry_span_creation() -> "Any":
                 result = None
-
-                integration = sentry_sdk.get_client().get_integration(
-                    AsyncioIntegration
-                )
+                client = sentry_sdk.get_client()
+                integration = client.get_integration(AsyncioIntegration)
                 task_spans = integration.task_spans if integration else False
 
+                span_ctx = None
+                is_span_streaming_enabled = has_span_streaming_enabled(client.options)
+
                 with sentry_sdk.isolation_scope():
-                    with (
-                        sentry_sdk.start_span(
-                            op=OP.FUNCTION,
-                            name=get_name(coro),
-                            origin=AsyncioIntegration.origin,
-                        )
-                        if task_spans
-                        else nullcontext()
-                    ):
+                    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,
+                                },
+                            )
+                        else:
+                            span_ctx = sentry_sdk.start_span(
+                                op=OP.FUNCTION,
+                                name=get_name(coro),
+                                origin=AsyncioIntegration.origin,
+                            )
+
+                    with span_ctx if span_ctx else nullcontext():
                         try:
                             result = await coro
                         except StopAsyncIteration as e:

tests/integrations/asyncio/test_asyncio.py

@@ -12,8 +12,8 @@
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations.asyncio import (
     AsyncioIntegration,
-    patch_asyncio,
     enable_asyncio_integration,
+    patch_asyncio,
 )
 
 try:
@@ -63,22 +63,30 @@ def get_sentry_task_factory(mock_get_running_loop):
 
 @minimum_python_38
 @pytest.mark.asyncio(loop_scope="module")
+@pytest.mark.parametrize("span_streaming", [True, False])
 async def test_create_task(
     sentry_init,
     capture_events,
+    capture_items,
+    span_streaming,
 ):
     sentry_init(
         traces_sample_rate=1.0,
         send_default_pii=True,
         integrations=[
             AsyncioIntegration(),
         ],
+        _experiments={
+            "trace_lifecycle": "stream" if span_streaming else "static",
+        },
     )
 
-    events = capture_events()
+    if span_streaming:
+        items = capture_items("span")
 
-    with sentry_sdk.start_transaction(name="test_transaction_for_create_task"):
-        with sentry_sdk.start_span(op="root", name="not so important"):
+        with sentry_sdk.traces.start_span(
+            name="not so important", attributes={"sentry.op": "root"}
+        ):
             foo_task = asyncio.create_task(foo())
             bar_task = asyncio.create_task(bar())
 
@@ -91,26 +99,61 @@ async def test_create_task(
 
             await asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
 
-    sentry_sdk.flush()
+    else:
+        events = capture_events()
 
-    (transaction_event,) = events
+        with sentry_sdk.start_transaction(name="test_transaction_for_create_task"):
+            with sentry_sdk.start_span(op="root", name="not so important"):
+                foo_task = asyncio.create_task(foo())
+                bar_task = asyncio.create_task(bar())
 
-    assert transaction_event["spans"][0]["op"] == "root"
-    assert transaction_event["spans"][0]["description"] == "not so important"
+                if hasattr(foo_task.get_coro(), "__name__"):
+                    assert foo_task.get_coro().__name__ == "foo"
+                if hasattr(bar_task.get_coro(), "__name__"):
+                    assert bar_task.get_coro().__name__ == "bar"
 
-    assert transaction_event["spans"][1]["op"] == OP.FUNCTION
-    assert transaction_event["spans"][1]["description"] == "foo"
-    assert (
-        transaction_event["spans"][1]["parent_span_id"]
-        == transaction_event["spans"][0]["span_id"]
-    )
+                tasks = [foo_task, bar_task]
 
-    assert transaction_event["spans"][2]["op"] == OP.FUNCTION
-    assert transaction_event["spans"][2]["description"] == "bar"
-    assert (
-        transaction_event["spans"][2]["parent_span_id"]
-        == transaction_event["spans"][0]["span_id"]
-    )
+                await asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
+
+    sentry_sdk.flush()
+
+    if span_streaming:
+        segment = items.pop().payload
+
+        assert segment["is_segment"] is True
+        assert segment["name"] == "not so important"
+        assert segment["attributes"]["sentry.op"] == "root"
+
+        spans = [item.payload for item in items]
+        assert len(spans) == 2
+
+        assert spans[0]["attributes"]["sentry.op"] == OP.FUNCTION
+        assert spans[0]["name"] == "foo"
+        assert spans[0]["parent_span_id"] == segment["span_id"]
+
+        assert spans[1]["attributes"]["sentry.op"] == OP.FUNCTION
+        assert spans[1]["name"] == "bar"
+        assert spans[1]["parent_span_id"] == segment["span_id"]
+    else:
+        (transaction_event,) = events
+
+        assert transaction_event["spans"][0]["op"] == "root"
+        assert transaction_event["spans"][0]["description"] == "not so important"
+
+        assert transaction_event["spans"][1]["op"] == OP.FUNCTION
+        assert transaction_event["spans"][1]["description"] == "foo"
+        assert (
+            transaction_event["spans"][1]["parent_span_id"]
+            == transaction_event["spans"][0]["span_id"]
+        )
+
+        assert transaction_event["spans"][2]["op"] == OP.FUNCTION
+        assert transaction_event["spans"][2]["description"] == "bar"
+        assert (
+            transaction_event["spans"][2]["parent_span_id"]
+            == transaction_event["spans"][0]["span_id"]
+        )
 
 
 @minimum_python_38