feat(asgi): Make integration fully span first compatible

sentry_sdk/integrations/_asgi_common.py

@@ -12,6 +12,7 @@
     from typing import Union
     from typing_extensions import Literal
 
+    from sentry_sdk._types import Attributes
     from sentry_sdk.utils import AnnotatedValue
 
 
@@ -105,3 +106,31 @@
         request_data["env"] = {"REMOTE_ADDR": _get_ip(asgi_scope)}
 
     return request_data
+
+
+def _get_request_attributes(asgi_scope: "Any") -> "dict[str, Any]":
+    """
+    Return attributes related to the HTTP request from the ASGI scope.
+    """
+    attributes: "Attributes" = {}
+
+    ty = asgi_scope["type"]
+    if ty in ("http", "websocket"):
+        if asgi_scope.get("method"):
+            attributes["http.request.method"] = asgi_scope["method"].upper()
+
+        headers = _filter_headers(_get_headers(asgi_scope))
+        for header, value in headers.items():
+            attributes[f"http.request.header.{header.lower()}"] = value
+
+        attributes["http.query"] = _get_query(asgi_scope)
+
+        attributes["url.full"] = _get_url(
+            asgi_scope, "http" if ty == "http" else "ws", headers.get("host")
+        )
+
+    client = asgi_scope.get("client")
+    if client and should_send_default_pii():
+        attributes["client.address"] = _get_ip(asgi_scope)
+
+    return attributes

sentry_sdk/integrations/asgi.py

@@ -15,6 +15,7 @@
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations._asgi_common import (
     _get_headers,
+    _get_request_attributes,
     _get_request_data,
     _get_url,
 )
@@ -23,7 +24,11 @@
     nullcontext,
 )
 from sentry_sdk.sessions import track_session
-from sentry_sdk.traces import StreamedSpan
+from sentry_sdk.traces import (
+    StreamedSpan,
+    SegmentSource,
+    SOURCE_FOR_STYLE as SEGMENT_SOURCE_FOR_STYLE,
+)
 from sentry_sdk.tracing import (
     SOURCE_FOR_STYLE,
     Transaction,
@@ -40,6 +45,7 @@
     _get_installed_modules,
     reraise,
     capture_internal_exceptions,
+    qualname_from_function,
 )
 
 from typing import TYPE_CHECKING
@@ -235,7 +241,7 @@ async def _run_app(
                                 transaction_source, "value", transaction_source
                             ),
                             "sentry.origin": self.span_origin,
-                            "asgi.type": ty,
+                            "network.protocol.name": ty,
                         }
 
                         if ty in ("http", "websocket"):
@@ -301,6 +307,9 @@ async def _run_app(
                             else nullcontext()
                         )
 
+                    for attribute, value in _get_request_attributes(scope).items():
+                        sentry_scope.set_attribute(attribute, value)
+
                     with span_ctx as span:
                         try:
 
@@ -336,6 +345,7 @@ async def _sentry_wrapped_send(
                                 return await self.app(
                                     scope, receive, _sentry_wrapped_send
                                 )
+
                         except Exception as exc:
                             suppress_chained_exceptions = (
                                 sentry_sdk.get_client()
@@ -350,6 +360,15 @@ async def _sentry_wrapped_send(
                             with capture_internal_exceptions():
                                 self._capture_request_exception(exc)
                             reraise(*exc_info)
+
+                        finally:
+                            with capture_internal_exceptions():
+                                name, source = self._get_segment_name_and_source(
+                                    self.transaction_style, scope
+                                )
+                                if isinstance(span, StreamedSpan):
+                                    span.name = name
+                                    span.set_attribute("sentry.span.source", source)
         finally:
             _asgi_middleware_applied.set(False)
 
@@ -424,3 +443,40 @@ def _get_transaction_name_and_source(
             return name, source
 
         return name, source
+
+    def _get_segment_name_and_source(
+        self: "SentryAsgiMiddleware", segment_style: str, asgi_scope: "Any"
+    ) -> "Tuple[str, str]":
+        name = None
+        source = SEGMENT_SOURCE_FOR_STYLE[segment_style].value
+        ty = asgi_scope.get("type")
+
+        if segment_style == "endpoint":
+            endpoint = asgi_scope.get("endpoint")
+            # Webframeworks like Starlette mutate the ASGI env once routing is
+            # done, which is sometime after the request has started. If we have
+            # an endpoint, overwrite our generic transaction name.
+            if endpoint:
+                name = qualname_from_function(endpoint) or ""
+            else:
+                name = _get_url(asgi_scope, "http" if ty == "http" else "ws", host=None)
+                source = SegmentSource.URL.value
+
+        elif segment_style == "url":
+            # FastAPI includes the route object in the scope to let Sentry extract the
+            # path from it for the transaction name
+            route = asgi_scope.get("route")
+            if route:
+                path = getattr(route, "path", None)
+                if path is not None:
+                    name = path
+            else:
+                name = _get_url(asgi_scope, "http" if ty == "http" else "ws", host=None)
+                source = SegmentSource.URL.value
+
+        if name is None:
+            name = _DEFAULT_TRANSACTION_NAME
+            source = SegmentSource.ROUTE.value
+            return name, source
+
+        return name, source

tests/conftest.py

@@ -7,6 +7,7 @@
 import brotli
 import gzip
 import io
+from dataclasses import dataclass
 from threading import Thread
 from contextlib import contextmanager
 from http.server import BaseHTTPRequestHandler, HTTPServer
@@ -320,6 +321,47 @@
     return inner
 
 
+@dataclass
+class UnwrappedItem:
+    type: str
+    payload: dict
+
+
+@pytest.fixture
+def capture_items(monkeypatch):
+    """Capture envelope payload, unfurling individual items."""
+
+    def inner(types=None):
+        telemetry = []
+        test_client = sentry_sdk.get_client()
+        old_capture_envelope = test_client.transport.capture_envelope
+
+        def append_envelope(envelope):
+            for item in envelope:
+                if types is None or item.type not in types:
+                    continue
+
+                if item.type in ("metric", "log", "span"):
+                    for json in item.payload.json["items"]:
+                        t = {k: v for k, v in json.items() if k != "attributes"}
+                        t["attributes"] = {
+                            k: v["value"] for k, v in json["attributes"].items()
+                        }
+                        telemetry.append(UnwrappedItem(type=item.type, payload=t))
+                else:
+                    telemetry.append(
+                        UnwrappedItem(type=item.type, payload=item.payload.json)
+                    )
+
+            return old_capture_envelope(envelope)
+
+        monkeypatch.setattr(test_client.transport, "capture_envelope", append_envelope)
+
+        return telemetry
+
+    return inner
+
+
 @pytest.fixture
 def capture_record_lost_event_calls(monkeypatch):
     def inner():
@@ -1212,6 +1254,29 @@
         client.set_cookie(key, value)
 
 
+def envelopes_to_spans(envelopes):
+    res: "list[dict[str, Any]]" = []
+    for envelope in envelopes:
+        for item in envelope.items:
+            if item.type == "span":
+                for span_json in item.payload.json["items"]:
+                    span = {
+                        "start_timestamp": span_json["start_timestamp"],
+                        "end_timestamp": span_json.get("end_timestamp"),
+                        "trace_id": span_json["trace_id"],
+                        "span_id": span_json["span_id"],
+                        "name": span_json["name"],
+                        "status": span_json["status"],
+                        "is_segment": span_json["is_segment"],
+                        "parent_span_id": span_json.get("parent_span_id"),
+                        "attributes": {
+                            k: v["value"] for (k, v) in span_json["attributes"].items()
+                        },
+                    }
+                    res.append(span)
+    return res
+
+
 @contextmanager
 def patch_start_tracing_child(
     fake_transaction_is_none: bool = False,