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
  )