feat(wsgi): Migrate WSGI integration to span first

Author: sentrivana

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_common.py

@@ -249,6 +249,53 @@ def _in_http_status_code_range(
     return False
 
 
+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.
+    """
+    from sentry_sdk._werkzeug import _get_headers
+    from sentry_sdk.integrations.wsgi import get_client_ip, get_request_url
+
+    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:
+        attributes["server.port"] = server_port
+
+    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
+
+
 class HttpCodeRangeContainer:
     """
     Wrapper to make it possible to use list[HttpStatusCodeRange] as a Container[int].

sentry_sdk/integrations/wsgi.py

@@ -9,11 +9,14 @@
 from sentry_sdk.integrations._wsgi_common import (
     DEFAULT_HTTP_METHODS_TO_CAPTURE,
     _filter_headers,
+    _get_request_attributes,
     nullcontext,
 )
 from sentry_sdk.scope import should_send_default_pii, use_isolation_scope
 from sentry_sdk.sessions import track_session
+from sentry_sdk.traces import StreamedSpan, SegmentSource
 from sentry_sdk.tracing import Transaction, TransactionSource
+from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import (
     ContextVar,
     capture_internal_exceptions,
@@ -22,7 +25,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 +56,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 +109,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 +126,71 @@ def __call__(
                         )
 
                     method = environ.get("REQUEST_METHOD", "").upper()
-                    transaction = None
+
+                    span_ctx: "ContextManager[Union[Transaction, 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": scope})
+
+                            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,
+                            )
 
-                    transaction_context = (
-                        sentry_sdk.start_transaction(
-                            transaction,
-                            custom_sampling_context={"wsgi_environ": environ},
-                        )
-                        if transaction is not None
-                        else nullcontext()
-                    )
-                    with transaction_context:
+                            span_ctx = sentry_sdk.start_transaction(
+                                transaction,
+                                custom_sampling_context={"wsgi_environ": environ},
+                            )
+
+                    with capture_internal_exceptions():
+                        for attr, value in _get_request_attributes(
+                            environ, self.use_x_forwarded_for
+                        ).items():
+                            scope.set_attribute(attr, value)
+
+                    span_ctx = span_ctx or nullcontext()
+
+                    with span_ctx as span:
                         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[Transaction, 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

tests/integrations/wsgi/test_wsgi.py

@@ -139,26 +139,50 @@ def test_keyboard_interrupt_is_captured(sentry_init, capture_events):
     assert event["level"] == "error"
 
 
+@pytest.mark.parametrize("span_streaming", [True, False])
 def test_transaction_with_error(
     sentry_init,
     crashing_app,
     capture_events,
+    capture_items,
     DictionaryContaining,  # noqa:N803
+    span_streaming,
 ):
     def dogpark(environ, start_response):
         raise ValueError("Fetch aborted. The ball was not returned.")
 
-    sentry_init(send_default_pii=True, traces_sample_rate=1.0)
+    sentry_init(
+        send_default_pii=True,
+        traces_sample_rate=1.0,
+        _experiments={
+            "trace_lifecycle": "stream" if span_streaming else "static",
+        },
+    )
     app = SentryWsgiMiddleware(dogpark)
     client = Client(app)
-    events = capture_events()
+
+    if span_streaming:
+        items = capture_items("event", "span")
+    else:
+        events = capture_events()
 
     with pytest.raises(ValueError):
         client.get("http://dogs.are.great/sit/stay/rollover/")
 
-    error_event, envelope = events
+    sentry_sdk.flush()
+
+    if span_streaming:
+        assert len(items) == 2
+        assert items[0].type == "event"
+        assert items[1].type == "span"
+
+        error_event = items[0].payload
+        span_item = items[1].payload
+    else:
+        error_event, envelope = events
+
+        assert error_event["transaction"] == "generic WSGI request"
 
-    assert error_event["transaction"] == "generic WSGI request"
     assert error_event["contexts"]["trace"]["op"] == "http.server"
     assert error_event["exception"]["values"][0]["type"] == "ValueError"
     assert error_event["exception"]["values"][0]["mechanism"]["type"] == "wsgi"
@@ -168,15 +192,20 @@ def dogpark(environ, start_response):
         == "Fetch aborted. The ball was not returned."
     )
 
-    assert envelope["type"] == "transaction"
+    if span_streaming:
+        assert span_item["trace_id"] == error_event["contexts"]["trace"]["trace_id"]
+        assert span_item["span_id"] == error_event["contexts"]["trace"]["span_id"]
+        assert span_item["status"] == "error"
+    else:
+        assert envelope["type"] == "transaction"
 
-    # event trace context is a subset of envelope trace context
-    assert envelope["contexts"]["trace"] == DictionaryContaining(
-        error_event["contexts"]["trace"]
-    )
-    assert envelope["contexts"]["trace"]["status"] == "internal_error"
-    assert envelope["transaction"] == error_event["transaction"]
-    assert envelope["request"] == error_event["request"]
+        # event trace context is a subset of envelope trace context
+        assert envelope["contexts"]["trace"] == DictionaryContaining(
+            error_event["contexts"]["trace"]
+        )
+        assert envelope["contexts"]["trace"]["status"] == "internal_error"
+        assert envelope["transaction"] == error_event["transaction"]
+        assert envelope["request"] == error_event["request"]
 
 
 def test_transaction_no_error(