sentry-sdk 2.30.0__py2.py3-none-any.whl → 3.0.0a2__py2.py3-none-any.whl

sentry_sdk/integrations/strawberry.py

@@ -107,14 +107,6 @@ def _patch_schema_init():
                 "False" if should_use_async_extension else "True",
             )
 
-        # remove the built in strawberry sentry extension, if present
-        extensions = [
-            extension
-            for extension in extensions
-            if extension
-            not in (StrawberrySentryAsyncExtension, StrawberrySentrySyncExtension)
-        ]
-
         # add our extension
         extensions.append(
             SentryAsyncExtension if should_use_async_extension else SentrySyncExtension
@@ -184,58 +176,52 @@ class SentryAsyncExtension(SchemaExtension):
         event_processor = _make_request_event_processor(self.execution_context)
         scope.add_event_processor(event_processor)
 
-        span = sentry_sdk.get_current_span()
-        if span:
-            self.graphql_span = span.start_child(
-                op=op,
-                name=description,
-                origin=StrawberryIntegration.origin,
-            )
-        else:
-            self.graphql_span = sentry_sdk.start_span(
-                op=op,
-                name=description,
-                origin=StrawberryIntegration.origin,
-            )
+        with sentry_sdk.start_span(
+            op=op,
+            name=description,
+            origin=StrawberryIntegration.origin,
+            only_if_parent=True,
+        ) as graphql_span:
+            graphql_span.set_attribute("graphql.operation.type", operation_type)
+            graphql_span.set_attribute("graphql.document", self.execution_context.query)
+            graphql_span.set_attribute("graphql.resource_name", self._resource_name)
+
+            yield
 
-        self.graphql_span.set_data("graphql.operation.type", operation_type)
-        self.graphql_span.set_data("graphql.operation.name", self._operation_name)
-        self.graphql_span.set_data("graphql.document", self.execution_context.query)
-        self.graphql_span.set_data("graphql.resource_name", self._resource_name)
+            # we might have a more accurate operation_name after the parsing
+            self._operation_name = self.execution_context.operation_name
 
-        yield
+            if self._operation_name is not None:
+                graphql_span.set_attribute(
+                    "graphql.operation.name", self._operation_name
+                )
 
-        transaction = self.graphql_span.containing_transaction
-        if transaction and self.execution_context.operation_name:
-            transaction.name = self.execution_context.operation_name
-            transaction.source = TransactionSource.COMPONENT
-            transaction.op = op
+                sentry_sdk.get_current_scope().set_transaction_name(
+                    self._operation_name,
+                    source=TransactionSource.COMPONENT,
+                )
 
-        self.graphql_span.finish()
+            root_span = graphql_span.root_span
+            if root_span:
+                root_span.op = op
 
     def on_validate(self):
         # type: () -> Generator[None, None, None]
-        self.validation_span = self.graphql_span.start_child(
+        with sentry_sdk.start_span(
             op=OP.GRAPHQL_VALIDATE,
             name="validation",
             origin=StrawberryIntegration.origin,
-        )
-
-        yield
-
-        self.validation_span.finish()
+        ):
+            yield
 
     def on_parse(self):
         # type: () -> Generator[None, None, None]
-        self.parsing_span = self.graphql_span.start_child(
+        with sentry_sdk.start_span(
             op=OP.GRAPHQL_PARSE,
             name="parsing",
             origin=StrawberryIntegration.origin,
-        )
-
-        yield
-
-        self.parsing_span.finish()
+        ):
+            yield
 
     def should_skip_tracing(self, _next, info):
         # type: (Callable[[Any, GraphQLResolveInfo, Any, Any], Any], GraphQLResolveInfo) -> bool
@@ -257,15 +243,15 @@ class SentryAsyncExtension(SchemaExtension):
 
         field_path = "{}.{}".format(info.parent_type, info.field_name)
 
-        with self.graphql_span.start_child(
+        with sentry_sdk.start_span(
             op=OP.GRAPHQL_RESOLVE,
             name="resolving {}".format(field_path),
             origin=StrawberryIntegration.origin,
         ) as span:
-            span.set_data("graphql.field_name", info.field_name)
-            span.set_data("graphql.parent_type", info.parent_type.name)
-            span.set_data("graphql.field_path", field_path)
-            span.set_data("graphql.path", ".".join(map(str, info.path.as_list())))
+            span.set_attribute("graphql.field_name", info.field_name)
+            span.set_attribute("graphql.parent_type", info.parent_type.name)
+            span.set_attribute("graphql.field_path", field_path)
+            span.set_attribute("graphql.path", ".".join(map(str, info.path.as_list())))
 
             return await self._resolve(_next, root, info, *args, **kwargs)
 
@@ -278,15 +264,15 @@ class SentrySyncExtension(SentryAsyncExtension):
 
         field_path = "{}.{}".format(info.parent_type, info.field_name)
 
-        with self.graphql_span.start_child(
+        with sentry_sdk.start_span(
             op=OP.GRAPHQL_RESOLVE,
             name="resolving {}".format(field_path),
             origin=StrawberryIntegration.origin,
         ) as span:
-            span.set_data("graphql.field_name", info.field_name)
-            span.set_data("graphql.parent_type", info.parent_type.name)
-            span.set_data("graphql.field_path", field_path)
-            span.set_data("graphql.path", ".".join(map(str, info.path.as_list())))
+            span.set_attribute("graphql.field_name", info.field_name)
+            span.set_attribute("graphql.parent_type", info.parent_type.name)
+            span.set_attribute("graphql.field_path", field_path)
+            span.set_attribute("graphql.path", ".".join(map(str, info.path.as_list())))
 
             return _next(root, info, *args, **kwargs)
 
@@ -383,11 +369,6 @@ def _make_response_event_processor(response_data):
 
 def _guess_if_using_async(extensions):
     # type: (List[SchemaExtension]) -> bool
-    if StrawberrySentryAsyncExtension in extensions:
-        return True
-    elif StrawberrySentrySyncExtension in extensions:
-        return False
-
     return bool(
         {"starlette", "starlite", "litestar", "fastapi"} & set(_get_installed_modules())
     )

sentry_sdk/integrations/threading.py

@@ -4,12 +4,12 @@ from functools import wraps
 from threading import Thread, current_thread
 
 import sentry_sdk
+from sentry_sdk import Scope
+from sentry_sdk.scope import ScopeType
 from sentry_sdk.integrations import Integration
-from sentry_sdk.scope import use_isolation_scope, use_scope
 from sentry_sdk.utils import (
     event_from_exception,
     capture_internal_exceptions,
-    logger,
     reraise,
 )
 
@@ -19,7 +19,6 @@ if TYPE_CHECKING:
     from typing import Any
     from typing import TypeVar
     from typing import Callable
-    from typing import Optional
 
     from sentry_sdk._types import ExcInfo
 
@@ -29,22 +28,10 @@ if TYPE_CHECKING:
 class ThreadingIntegration(Integration):
     identifier = "threading"
 
-    def __init__(self, propagate_hub=None, propagate_scope=True):
-        # type: (Optional[bool], bool) -> None
-        if propagate_hub is not None:
-            logger.warning(
-                "Deprecated: propagate_hub is deprecated. This will be removed in the future."
-            )
-
-        # Note: propagate_hub did not have any effect on propagation of scope data
-        # scope data was always propagated no matter what the value of propagate_hub was
-        # This is why the default for propagate_scope is True
-
+    def __init__(self, propagate_scope=True):
+        # type: (bool) -> None
         self.propagate_scope = propagate_scope
 
-        if propagate_hub is not None:
-            self.propagate_scope = propagate_hub
-
     @staticmethod
     def setup_once():
         # type: () -> None
@@ -89,8 +76,8 @@ class ThreadingIntegration(Integration):
                     isolation_scope = sentry_sdk.get_isolation_scope().fork()
                     current_scope = sentry_sdk.get_current_scope().fork()
             else:
-                isolation_scope = None
-                current_scope = None
+                isolation_scope = Scope(ty=ScopeType.ISOLATION)
+                current_scope = Scope(ty=ScopeType.CURRENT)
 
             # Patching instance methods in `start()` creates a reference cycle if
             # done in a naive way. See
@@ -112,7 +99,7 @@ class ThreadingIntegration(Integration):
 
 
 def _wrap_run(isolation_scope_to_use, current_scope_to_use, old_run_func):
-    # type: (Optional[sentry_sdk.Scope], Optional[sentry_sdk.Scope], F) -> F
+    # type: (sentry_sdk.Scope, sentry_sdk.Scope, F) -> F
     @wraps(old_run_func)
     def run(*a, **kw):
         # type: (*Any, **Any) -> Any
@@ -124,12 +111,9 @@ def _wrap_run(isolation_scope_to_use, current_scope_to_use, old_run_func):
             except Exception:
                 reraise(*_capture_exception())
 
-        if isolation_scope_to_use is not None and current_scope_to_use is not None:
-            with use_isolation_scope(isolation_scope_to_use):
-                with use_scope(current_scope_to_use):
-                    return _run_old_run_func()
-        else:
-            return _run_old_run_func()
+        with sentry_sdk.use_isolation_scope(isolation_scope_to_use):
+            with sentry_sdk.use_scope(current_scope_to_use):
+                return _run_old_run_func()
 
     return run  # type: ignore
 

sentry_sdk/integrations/tornado.py

@@ -3,7 +3,6 @@ import contextlib
 from inspect import iscoroutinefunction
 
 import sentry_sdk
-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.tracing import TransactionSource
@@ -20,13 +19,15 @@ from sentry_sdk.integrations._wsgi_common import (
     RequestExtractor,
     _filter_headers,
     _is_json_content_type,
+    _request_headers_to_span_attributes,
 )
 from sentry_sdk.integrations.logging import ignore_logger
 
 try:
     from tornado import version_info as TORNADO_VERSION
-    from tornado.web import RequestHandler, HTTPError
     from tornado.gen import coroutine
+    from tornado.httputil import HTTPServerRequest
+    from tornado.web import RequestHandler, HTTPError
 except ImportError:
     raise DidNotEnable("Tornado not installed")
 
@@ -42,6 +43,14 @@ if TYPE_CHECKING:
     from sentry_sdk._types import Event, EventProcessor
 
 
+REQUEST_PROPERTY_TO_ATTRIBUTE = {
+    "method": "http.request.method",
+    "path": "url.path",
+    "query": "url.query",
+    "protocol": "url.scheme",
+}
+
+
 class TornadoIntegration(Integration):
     identifier = "tornado"
     origin = f"auto.http.{identifier}"
@@ -111,22 +120,19 @@ def _handle_request_impl(self):
         processor = _make_event_processor(weak_handler)
         scope.add_event_processor(processor)
 
-        transaction = continue_trace(
-            headers,
-            op=OP.HTTP_SERVER,
-            # Like with all other integrations, this is our
-            # fallback transaction in case there is no route.
-            # sentry_urldispatcher_resolve is responsible for
-            # setting a transaction name later.
-            name="generic Tornado request",
-            source=TransactionSource.ROUTE,
-            origin=TornadoIntegration.origin,
-        )
-
-        with sentry_sdk.start_transaction(
-            transaction, custom_sampling_context={"tornado_request": self.request}
-        ):
-            yield
+        with sentry_sdk.continue_trace(headers):
+            with sentry_sdk.start_span(
+                op=OP.HTTP_SERVER,
+                # Like with all other integrations, this is our
+                # fallback transaction in case there is no route.
+                # sentry_urldispatcher_resolve is responsible for
+                # setting a transaction name later.
+                name="generic Tornado request",
+                source=TransactionSource.ROUTE,
+                origin=TornadoIntegration.origin,
+                attributes=_prepopulate_attributes(self.request),
+            ):
+                yield
 
 
 @ensure_integration_enabled(TornadoIntegration)
@@ -218,3 +224,36 @@ class TornadoRequestExtractor(RequestExtractor):
     def size_of_file(self, file):
         # type: (Any) -> int
         return len(file.body or ())
+
+
+def _prepopulate_attributes(request):
+    # type: (HTTPServerRequest) -> dict[str, Any]
+    # https://www.tornadoweb.org/en/stable/httputil.html#tornado.httputil.HTTPServerRequest
+    attributes = {}
+
+    for prop, attr in REQUEST_PROPERTY_TO_ATTRIBUTE.items():
+        if getattr(request, prop, None) is not None:
+            attributes[attr] = getattr(request, prop)
+
+    if getattr(request, "version", None):
+        try:
+            proto, version = request.version.split("/")
+            attributes["network.protocol.name"] = proto
+            attributes["network.protocol.version"] = version
+        except ValueError:
+            attributes["network.protocol.name"] = request.version
+
+    if getattr(request, "host", None):
+        try:
+            address, port = request.host.split(":")
+            attributes["server.address"] = address
+            attributes["server.port"] = port
+        except ValueError:
+            attributes["server.address"] = request.host
+
+    with capture_internal_exceptions():
+        attributes["url.full"] = request.full_url()
+
+    attributes.update(_request_headers_to_span_attributes(request.headers))
+
+    return attributes

sentry_sdk/integrations/trytond.py

@@ -1,8 +1,9 @@
 import sentry_sdk
-from sentry_sdk.integrations import Integration
+from sentry_sdk.integrations import _check_minimum_version, Integration
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
 from sentry_sdk.utils import ensure_integration_enabled, event_from_exception
 
+from trytond import __version__ as trytond_version  # type: ignore
 from trytond.exceptions import TrytonException  # type: ignore
 from trytond.wsgi import app  # type: ignore
 
@@ -19,6 +20,8 @@ class TrytondWSGIIntegration(Integration):
 
     @staticmethod
     def setup_once():  # type: () -> None
+        _check_minimum_version(TrytondWSGIIntegration, trytond_version)
+
         app.wsgi_app = SentryWsgiMiddleware(
             app.wsgi_app,
             span_origin=TrytondWSGIIntegration.origin,

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)