feat(wsgi): Migrate to span first

sentry_sdk/integrations/_asgi_common.py

@@ -132,6 +132,8 @@ def _get_request_attributes(asgi_scope: "Any") -> "dict[str, Any]":
 
     client = asgi_scope.get("client")
     if client and should_send_default_pii():
-        attributes["client.address"] = _get_ip(asgi_scope)
+        ip = _get_ip(asgi_scope)
+        attributes["client.address"] = ip
+        attributes["user.ip_address"] = ip
 
     return attributes

sentry_sdk/integrations/wsgi.py

@@ -13,7 +13,9 @@
 )
 from sentry_sdk.scope import should_send_default_pii, use_isolation_scope
 from sentry_sdk.sessions import track_session
-from sentry_sdk.tracing import Transaction, TransactionSource
+from sentry_sdk.traces import StreamedSpan, SegmentSource
+from sentry_sdk.tracing import Span, TransactionSource
+from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import (
     ContextVar,
     capture_internal_exceptions,
@@ -22,7 +24,18 @@
 )
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Dict, Iterator, Optional, Protocol, Tuple, TypeVar
+    from typing import (
+        Any,
+        Callable,
+        ContextManager,
+        Dict,
+        Iterator,
+        Optional,
+        Protocol,
+        Tuple,
+        TypeVar,
+        Union,
+    )
 
     from sentry_sdk._types import Event, EventProcessor
     from sentry_sdk.utils import ExcInfo
@@ -42,6 +55,7 @@ def __call__(
 
 
 _wsgi_middleware_applied = ContextVar("sentry_wsgi_middleware_applied")
+_DEFAULT_TRANSACTION_NAME = "generic WSGI request"
 
 
 def wsgi_decoding_dance(s: str, charset: str = "utf-8", errors: str = "replace") -> str:
@@ -94,6 +108,9 @@ def __call__(
         if _wsgi_middleware_applied.get(False):
             return self.app(environ, start_response)
 
+        client = sentry_sdk.get_client()
+        span_streaming = has_span_streaming_enabled(client.options)
+
         _wsgi_middleware_applied.set(True)
         try:
             with sentry_sdk.isolation_scope() as scope:
@@ -108,34 +125,72 @@ def __call__(
                         )
 
                     method = environ.get("REQUEST_METHOD", "").upper()
-                    transaction = None
+
+                    span_ctx: "Optional[ContextManager[Union[Span, StreamedSpan, None]]]" = None
                     if method in self.http_methods_to_capture:
-                        transaction = continue_trace(
-                            environ,
-                            op=OP.HTTP_SERVER,
-                            name="generic WSGI request",
-                            source=TransactionSource.ROUTE,
-                            origin=self.span_origin,
-                        )
+                        if span_streaming:
+                            sentry_sdk.traces.continue_trace(
+                                dict(_get_headers(environ))
+                            )
+                            scope.set_custom_sampling_context({"wsgi_environ": environ})
+
+                            span_ctx = sentry_sdk.traces.start_span(
+                                name=_DEFAULT_TRANSACTION_NAME,
+                                attributes={
+                                    "sentry.span.source": SegmentSource.ROUTE,
+                                    "sentry.origin": self.span_origin,
+                                    "sentry.op": OP.HTTP_SERVER,
+                                },
+                            )
+                        else:
+                            transaction = continue_trace(
+                                environ,
+                                op=OP.HTTP_SERVER,
+                                name=_DEFAULT_TRANSACTION_NAME,
+                                source=TransactionSource.ROUTE,
+                                origin=self.span_origin,
+                            )
+
+                            span_ctx = sentry_sdk.start_transaction(
+                                transaction,
+                                custom_sampling_context={"wsgi_environ": environ},
+                            )
+
+                    span_ctx = span_ctx or nullcontext()
+
+                    with span_ctx as span:
+                        if isinstance(span, StreamedSpan):
+                            with capture_internal_exceptions():
+                                for attr, value in _get_request_attributes(
+                                    environ, self.use_x_forwarded_for
+                                ).items():
+                                    span.set_attribute(attr, value)
 
-                    transaction_context = (
-                        sentry_sdk.start_transaction(
-                            transaction,
-                            custom_sampling_context={"wsgi_environ": environ},
-                        )
-                        if transaction is not None
-                        else nullcontext()
-                    )
-                    with transaction_context:
                         try:
                             response = self.app(
                                 environ,
-                                partial(
-                                    _sentry_start_response, start_response, transaction
-                                ),
+                                partial(_sentry_start_response, start_response, span),
                             )
                         except BaseException:
                             reraise(*_capture_exception())
+                        finally:
+                            if isinstance(span, StreamedSpan):
+                                already_set = (
+                                    span.name != _DEFAULT_TRANSACTION_NAME
+                                    and span.get_attributes().get("sentry.span.source")
+                                    in [
+                                        SegmentSource.COMPONENT.value,
+                                        SegmentSource.ROUTE.value,
+                                        SegmentSource.CUSTOM.value,
+                                    ]
+                                )
+                                if not already_set:
+                                    with capture_internal_exceptions():
+                                        span.name = _DEFAULT_TRANSACTION_NAME
+                                        span.set_attribute(
+                                            "sentry.span.source",
+                                            SegmentSource.ROUTE.value,
+                                        )
         finally:
             _wsgi_middleware_applied.set(False)
 
@@ -167,15 +222,19 @@ def __call__(
 
 def _sentry_start_response(
     old_start_response: "StartResponse",
-    transaction: "Optional[Transaction]",
+    span: "Optional[Union[Span, StreamedSpan]]",
     status: str,
     response_headers: "WsgiResponseHeaders",
     exc_info: "Optional[WsgiExcInfo]" = None,
 ) -> "WsgiResponseIter":  # type: ignore[type-var]
     with capture_internal_exceptions():
         status_int = int(status.split(" ", 1)[0])
-        if transaction is not None:
-            transaction.set_http_status(status_int)
+        if span is not None:
+            if isinstance(span, StreamedSpan):
+                span.status = "error" if status_int >= 400 else "ok"
+                span.set_attribute("http.response.status_code", status_int)
+            else:
+                span.set_http_status(status_int)
 
     if exc_info is None:
         # The Django Rest Framework WSGI test client, and likely other
@@ -326,3 +385,50 @@ def event_processor(event: "Event", hint: "Dict[str, Any]") -> "Event":
         return event
 
     return event_processor
+
+
+def _get_request_attributes(
+    environ: "Dict[str, str]",
+    use_x_forwarded_for: bool = False,
+) -> "Dict[str, Any]":
+    """
+    Return span attributes related to the HTTP request from the WSGI environ.
+    """
+    attributes: "dict[str, Any]" = {}
+
+    method = environ.get("REQUEST_METHOD")
+    if method:
+        attributes["http.request.method"] = method.upper()
+
+    headers = _filter_headers(dict(_get_headers(environ)), use_annotated_value=False)
+    for header, value in headers.items():
+        attributes[f"http.request.header.{header.lower()}"] = value
+
+    query_string = environ.get("QUERY_STRING")
+    if query_string:
+        attributes["http.query"] = query_string
+
+    attributes["url.full"] = get_request_url(environ, use_x_forwarded_for)
+
+    url_scheme = environ.get("wsgi.url_scheme")
+    if url_scheme:
+        attributes["network.protocol.name"] = url_scheme
+
+    server_name = environ.get("SERVER_NAME")
+    if server_name:
+        attributes["server.address"] = server_name
+
+    server_port = environ.get("SERVER_PORT")
+    if server_port:
+        try:
+            attributes["server.port"] = int(server_port)
+        except ValueError:
+            pass
+
+    if should_send_default_pii():
+        client_ip = get_client_ip(environ)
+        if client_ip:
+            attributes["client.address"] = client_ip
+            attributes["user.ip_address"] = client_ip
+
+    return attributes

sentry_sdk/scope.py

@@ -714,7 +714,7 @@ def get_active_propagation_context(self) -> "PropagationContext":
     def set_custom_sampling_context(
         self, custom_sampling_context: "dict[str, Any]"
     ) -> None:
-        self.get_active_propagation_context()._set_custom_sampling_context(
+        self.get_current_scope().get_active_propagation_context()._set_custom_sampling_context(
             custom_sampling_context
         )