sentry-sdk 2.27.0__py2.py3-none-any.whl → 3.0.0a1__py2.py3-none-any.whl

sentry_sdk/integrations/wsgi.py

@@ -3,17 +3,15 @@ from functools import partial
 
 import sentry_sdk
 from sentry_sdk._werkzeug import get_host, _get_headers
-from sentry_sdk.api import continue_trace
 from sentry_sdk.consts import OP
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.integrations._wsgi_common import (
     DEFAULT_HTTP_METHODS_TO_CAPTURE,
     _filter_headers,
-    nullcontext,
+    _request_headers_to_span_attributes,
 )
 from sentry_sdk.sessions import track_session
-from sentry_sdk.scope import use_isolation_scope
-from sentry_sdk.tracing import Transaction, TransactionSource
+from sentry_sdk.tracing import Span, TransactionSource
 from sentry_sdk.utils import (
     ContextVar,
     capture_internal_exceptions,
@@ -48,6 +46,17 @@ if TYPE_CHECKING:
 
 _wsgi_middleware_applied = ContextVar("sentry_wsgi_middleware_applied")
 
+DEFAULT_TRANSACTION_NAME = "generic WSGI request"
+
+ENVIRON_TO_ATTRIBUTE = {
+    "PATH_INFO": "url.path",
+    "QUERY_STRING": "url.query",
+    "REQUEST_METHOD": "http.request.method",
+    "SERVER_NAME": "server.address",
+    "SERVER_PORT": "server.port",
+    "wsgi.url_scheme": "url.scheme",
+}
+
 
 def wsgi_decoding_dance(s, charset="utf-8", errors="replace"):
     # type: (str, str, str) -> str
@@ -81,7 +90,7 @@ class SentryWsgiMiddleware:
         self,
         app,  # type: Callable[[Dict[str, str], Callable[..., Any]], Any]
         use_x_forwarded_for=False,  # type: bool
-        span_origin="manual",  # type: str
+        span_origin=None,  # type: Optional[str]
         http_methods_to_capture=DEFAULT_HTTP_METHODS_TO_CAPTURE,  # type: Tuple[str, ...]
     ):
         # type: (...) -> None
@@ -98,6 +107,10 @@ class SentryWsgiMiddleware:
         _wsgi_middleware_applied.set(True)
         try:
             with sentry_sdk.isolation_scope() as scope:
+                scope.set_transaction_name(
+                    DEFAULT_TRANSACTION_NAME, source=TransactionSource.ROUTE
+                )
+
                 with track_session(scope, session_mode="request"):
                     with capture_internal_exceptions():
                         scope.clear_breadcrumbs()
@@ -107,44 +120,48 @@ class SentryWsgiMiddleware:
                                 environ, self.use_x_forwarded_for
                             )
                         )
-
                     method = environ.get("REQUEST_METHOD", "").upper()
-                    transaction = 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,
-                        )
-
-                    with (
-                        sentry_sdk.start_transaction(
-                            transaction,
-                            custom_sampling_context={"wsgi_environ": environ},
-                        )
-                        if transaction is not None
-                        else nullcontext()
-                    ):
-                        try:
-                            response = self.app(
-                                environ,
-                                partial(
-                                    _sentry_start_response, start_response, transaction
+                    should_trace = method in self.http_methods_to_capture
+                    if should_trace:
+                        with sentry_sdk.continue_trace(environ):
+                            with sentry_sdk.start_span(
+                                op=OP.HTTP_SERVER,
+                                name=DEFAULT_TRANSACTION_NAME,
+                                source=TransactionSource.ROUTE,
+                                origin=self.span_origin,
+                                attributes=_prepopulate_attributes(
+                                    environ, self.use_x_forwarded_for
                                 ),
-                            )
-                        except BaseException:
-                            reraise(*_capture_exception())
+                            ) as span:
+                                response = self._run_original_app(
+                                    environ, start_response, span
+                                )
+                    else:
+                        response = self._run_original_app(environ, start_response, None)
+
         finally:
             _wsgi_middleware_applied.set(False)
 
         return _ScopedResponse(scope, response)
 
+    def _run_original_app(self, environ, start_response, span):
+        # type: (dict[str, str], StartResponse, Optional[Span]) -> Any
+        try:
+            return self.app(
+                environ,
+                partial(
+                    _sentry_start_response,
+                    start_response,
+                    span,
+                ),
+            )
+        except BaseException:
+            reraise(*_capture_exception())
+
 
 def _sentry_start_response(  # type: ignore
     old_start_response,  # type: StartResponse
-    transaction,  # type: Optional[Transaction]
+    span,  # type: Optional[Span]
     status,  # type: str
     response_headers,  # type: WsgiResponseHeaders
     exc_info=None,  # type: Optional[WsgiExcInfo]
@@ -152,8 +169,8 @@ def _sentry_start_response(  # type: ignore
     # type: (...) -> WsgiResponseIter
     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:
+            span.set_http_status(status_int)
 
     if exc_info is None:
         # The Django Rest Framework WSGI test client, and likely other
@@ -237,7 +254,7 @@ class _ScopedResponse:
     __slots__ = ("_response", "_scope")
 
     def __init__(self, scope, response):
-        # type: (sentry_sdk.scope.Scope, Iterator[bytes]) -> None
+        # type: (sentry_sdk.Scope, Iterator[bytes]) -> None
         self._scope = scope
         self._response = response
 
@@ -246,7 +263,7 @@ class _ScopedResponse:
         iterator = iter(self._response)
 
         while True:
-            with use_isolation_scope(self._scope):
+            with sentry_sdk.use_isolation_scope(self._scope):
                 try:
                     chunk = next(iterator)
                 except StopIteration:
@@ -258,7 +275,7 @@ class _ScopedResponse:
 
     def close(self):
         # type: () -> None
-        with use_isolation_scope(self._scope):
+        with sentry_sdk.use_isolation_scope(self._scope):
             try:
                 self._response.close()  # type: ignore
             except AttributeError:
@@ -308,3 +325,32 @@ def _make_wsgi_event_processor(environ, use_x_forwarded_for):
         return event
 
     return event_processor
+
+
+def _prepopulate_attributes(wsgi_environ, use_x_forwarded_for=False):
+    # type: (dict[str, str], bool) -> dict[str, str]
+    """Extract span attributes from the WSGI environment."""
+    attributes = {}
+
+    for property, attr in ENVIRON_TO_ATTRIBUTE.items():
+        if wsgi_environ.get(property) is not None:
+            attributes[attr] = wsgi_environ[property]
+
+    if wsgi_environ.get("SERVER_PROTOCOL") is not None:
+        try:
+            proto, version = wsgi_environ["SERVER_PROTOCOL"].split("/")
+            attributes["network.protocol.name"] = proto
+            attributes["network.protocol.version"] = version
+        except Exception:
+            attributes["network.protocol.name"] = wsgi_environ["SERVER_PROTOCOL"]
+
+    with capture_internal_exceptions():
+        url = get_request_url(wsgi_environ, use_x_forwarded_for)
+        query = wsgi_environ.get("QUERY_STRING")
+        attributes["url.full"] = f"{url}?{query}"
+
+    attributes.update(
+        _request_headers_to_span_attributes(dict(_get_headers(wsgi_environ)))
+    )
+
+    return attributes

sentry_sdk/opentelemetry/__init__.py

@@ -0,0 +1,9 @@
+from sentry_sdk.opentelemetry.propagator import SentryPropagator
+from sentry_sdk.opentelemetry.sampler import SentrySampler
+from sentry_sdk.opentelemetry.span_processor import SentrySpanProcessor
+
+__all__ = [
+    "SentryPropagator",
+    "SentrySampler",
+    "SentrySpanProcessor",
+]

sentry_sdk/opentelemetry/consts.py

@@ -0,0 +1,33 @@
+from opentelemetry.context import create_key
+from sentry_sdk.tracing_utils import Baggage
+
+
+# propagation keys
+SENTRY_TRACE_KEY = create_key("sentry-trace")
+SENTRY_BAGGAGE_KEY = create_key("sentry-baggage")
+
+# scope management keys
+SENTRY_SCOPES_KEY = create_key("sentry_scopes")
+SENTRY_FORK_ISOLATION_SCOPE_KEY = create_key("sentry_fork_isolation_scope")
+SENTRY_USE_CURRENT_SCOPE_KEY = create_key("sentry_use_current_scope")
+SENTRY_USE_ISOLATION_SCOPE_KEY = create_key("sentry_use_isolation_scope")
+
+# trace state keys
+TRACESTATE_SAMPLED_KEY = Baggage.SENTRY_PREFIX + "sampled"
+TRACESTATE_SAMPLE_RATE_KEY = Baggage.SENTRY_PREFIX + "sample_rate"
+TRACESTATE_SAMPLE_RAND_KEY = Baggage.SENTRY_PREFIX + "sample_rand"
+
+# misc
+OTEL_SENTRY_CONTEXT = "otel"
+SPAN_ORIGIN = "auto.otel"
+
+
+class SentrySpanAttribute:
+    DESCRIPTION = "sentry.description"
+    OP = "sentry.op"
+    ORIGIN = "sentry.origin"
+    TAG = "sentry.tag"
+    NAME = "sentry.name"
+    SOURCE = "sentry.source"
+    CONTEXT = "sentry.context"
+    CUSTOM_SAMPLED = "sentry.custom_sampled"  # used for saving start_span(sampled=X)

sentry_sdk/opentelemetry/contextvars_context.py

@@ -0,0 +1,73 @@
+from typing import cast, TYPE_CHECKING
+
+from opentelemetry.trace import set_span_in_context
+from opentelemetry.context import Context, get_value, set_value
+from opentelemetry.context.contextvars_context import ContextVarsRuntimeContext
+
+import sentry_sdk
+from sentry_sdk.opentelemetry.consts import (
+    SENTRY_SCOPES_KEY,
+    SENTRY_FORK_ISOLATION_SCOPE_KEY,
+    SENTRY_USE_CURRENT_SCOPE_KEY,
+    SENTRY_USE_ISOLATION_SCOPE_KEY,
+)
+
+if TYPE_CHECKING:
+    from typing import Optional
+    from contextvars import Token
+    import sentry_sdk.opentelemetry.scope as scope
+
+
+class SentryContextVarsRuntimeContext(ContextVarsRuntimeContext):
+    def attach(self, context):
+        # type: (Context) -> Token[Context]
+        scopes = get_value(SENTRY_SCOPES_KEY, context)
+
+        should_fork_isolation_scope = context.pop(
+            SENTRY_FORK_ISOLATION_SCOPE_KEY, False
+        )
+        should_fork_isolation_scope = cast("bool", should_fork_isolation_scope)
+
+        should_use_isolation_scope = context.pop(SENTRY_USE_ISOLATION_SCOPE_KEY, None)
+        should_use_isolation_scope = cast(
+            "Optional[scope.PotelScope]", should_use_isolation_scope
+        )
+
+        should_use_current_scope = context.pop(SENTRY_USE_CURRENT_SCOPE_KEY, None)
+        should_use_current_scope = cast(
+            "Optional[scope.PotelScope]", should_use_current_scope
+        )
+
+        if scopes:
+            scopes = cast("tuple[scope.PotelScope, scope.PotelScope]", scopes)
+            (current_scope, isolation_scope) = scopes
+        else:
+            current_scope = sentry_sdk.get_current_scope()
+            isolation_scope = sentry_sdk.get_isolation_scope()
+
+        new_context = context
+
+        if should_use_current_scope:
+            new_scope = should_use_current_scope
+
+            # the main case where we use use_scope is for
+            # scope propagation in the ThreadingIntegration
+            # so we need to carry forward the span reference explicitly too
+            span = should_use_current_scope.span
+            if span:
+                new_context = set_span_in_context(span._otel_span, new_context)
+
+        else:
+            new_scope = current_scope.fork()
+
+        if should_use_isolation_scope:
+            new_isolation_scope = should_use_isolation_scope
+        elif should_fork_isolation_scope:
+            new_isolation_scope = isolation_scope.fork()
+        else:
+            new_isolation_scope = isolation_scope
+
+        new_scopes = (new_scope, new_isolation_scope)
+
+        new_context = set_value(SENTRY_SCOPES_KEY, new_scopes, new_context)
+        return super().attach(new_context)

sentry_sdk/{integrations/opentelemetry → opentelemetry}/propagator.py

@@ -1,7 +1,10 @@
+from typing import cast
+
 from opentelemetry import trace
 from opentelemetry.context import (
     Context,
     get_current,
+    get_value,
     set_value,
 )
 from opentelemetry.propagators.textmap import (
@@ -18,23 +21,22 @@ from opentelemetry.trace import (
     TraceFlags,
 )
 
-from sentry_sdk.integrations.opentelemetry.consts import (
-    SENTRY_BAGGAGE_KEY,
-    SENTRY_TRACE_KEY,
-)
-from sentry_sdk.integrations.opentelemetry.span_processor import (
-    SentrySpanProcessor,
-)
-from sentry_sdk.tracing import (
+from sentry_sdk.consts import (
     BAGGAGE_HEADER_NAME,
     SENTRY_TRACE_HEADER_NAME,
 )
+from sentry_sdk.opentelemetry.consts import (
+    SENTRY_BAGGAGE_KEY,
+    SENTRY_TRACE_KEY,
+    SENTRY_SCOPES_KEY,
+)
 from sentry_sdk.tracing_utils import Baggage, extract_sentrytrace_data
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Optional, Set
+    import sentry_sdk.opentelemetry.scope as scope
 
 
 class SentryPropagator(TextMapPropagator):
@@ -47,6 +49,7 @@ class SentryPropagator(TextMapPropagator):
         if context is None:
             context = get_current()
 
+        # TODO-neel-potel cleanup with continue_trace / isolation_scope
         sentry_trace = getter.get(carrier, SENTRY_TRACE_HEADER_NAME)
         if not sentry_trace:
             return context
@@ -89,27 +92,15 @@ class SentryPropagator(TextMapPropagator):
         if context is None:
             context = get_current()
 
-        current_span = trace.get_current_span(context)
-        current_span_context = current_span.get_span_context()
-
-        if not current_span_context.is_valid:
-            return
-
-        span_id = trace.format_span_id(current_span_context.span_id)
-
-        span_map = SentrySpanProcessor().otel_span_map
-        sentry_span = span_map.get(span_id, None)
-        if not sentry_span:
-            return
-
-        setter.set(carrier, SENTRY_TRACE_HEADER_NAME, sentry_span.to_traceparent())
+        scopes = get_value(SENTRY_SCOPES_KEY, context)
+        if scopes:
+            scopes = cast("tuple[scope.PotelScope, scope.PotelScope]", scopes)
+            (current_scope, _) = scopes
 
-        if sentry_span.containing_transaction:
-            baggage = sentry_span.containing_transaction.get_baggage()
-            if baggage:
-                baggage_data = baggage.serialize()
-                if baggage_data:
-                    setter.set(carrier, BAGGAGE_HEADER_NAME, baggage_data)
+            # TODO-neel-potel check trace_propagation_targets
+            # TODO-neel-potel test propagator works with twp
+            for key, value in current_scope.iter_trace_propagation_headers():
+                setter.set(carrier, key, value)
 
     @property
     def fields(self):