sentry-sdk 0.18.0__py2.py3-none-any.whl → 2.46.0__py2.py3-none-any.whl

sentry_sdk/integrations/tornado.py

@@ -1,49 +1,55 @@
 import weakref
+import contextlib
 from inspect import iscoroutinefunction
 
-from sentry_sdk.hub import Hub, _should_send_default_pii
+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
 from sentry_sdk.utils import (
     HAS_REAL_CONTEXTVARS,
     CONTEXTVARS_ERROR_MESSAGE,
+    ensure_integration_enabled,
     event_from_exception,
     capture_internal_exceptions,
     transaction_from_function,
 )
-from sentry_sdk.integrations import Integration, DidNotEnable
+from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
 from sentry_sdk.integrations._wsgi_common import (
     RequestExtractor,
     _filter_headers,
     _is_json_content_type,
 )
 from sentry_sdk.integrations.logging import ignore_logger
-from sentry_sdk._compat import iteritems
 
 try:
-    from tornado import version_info as TORNADO_VERSION  # type: ignore
+    from tornado import version_info as TORNADO_VERSION
     from tornado.web import RequestHandler, HTTPError
     from tornado.gen import coroutine
 except ImportError:
     raise DidNotEnable("Tornado not installed")
 
-from sentry_sdk._types import MYPY
+from typing import TYPE_CHECKING
 
-if MYPY:
+if TYPE_CHECKING:
     from typing import Any
     from typing import Optional
     from typing import Dict
     from typing import Callable
+    from typing import Generator
 
-    from sentry_sdk._types import EventProcessor
+    from sentry_sdk._types import Event, EventProcessor
 
 
 class TornadoIntegration(Integration):
     identifier = "tornado"
+    origin = f"auto.http.{identifier}"
 
     @staticmethod
     def setup_once():
         # type: () -> None
-        if TORNADO_VERSION < (5, 0):
-            raise DidNotEnable("Tornado 5+ required")
+        _check_minimum_version(TornadoIntegration, TORNADO_VERSION)
 
         if not HAS_REAL_CONTEXTVARS:
             # Tornado is async. We better have contextvars or we're going to leak
@@ -55,7 +61,7 @@ class TornadoIntegration(Integration):
 
         ignore_logger("tornado.access")
 
-        old_execute = RequestHandler._execute  # type: ignore
+        old_execute = RequestHandler._execute
 
         awaitable = iscoroutinefunction(old_execute)
 
@@ -63,19 +69,8 @@ class TornadoIntegration(Integration):
             # Starting Tornado 6 RequestHandler._execute method is a standard Python coroutine (async/await)
             # In that case our method should be a coroutine function too
             async def sentry_execute_request_handler(self, *args, **kwargs):
-                # type: (Any, *Any, **Any) -> Any
-                hub = Hub.current
-                integration = hub.get_integration(TornadoIntegration)
-                if integration is None:
-                    return await old_execute(self, *args, **kwargs)
-
-                weak_handler = weakref.ref(self)
-
-                with Hub(hub) as hub:
-                    with hub.configure_scope() as scope:
-                        scope.clear_breadcrumbs()
-                        processor = _make_event_processor(weak_handler)  # type: ignore
-                        scope.add_event_processor(processor)
+                # type: (RequestHandler, *Any, **Any) -> Any
+                with _handle_request_impl(self):
                     return await old_execute(self, *args, **kwargs)
 
         else:
@@ -83,57 +78,76 @@ class TornadoIntegration(Integration):
             @coroutine  # type: ignore
             def sentry_execute_request_handler(self, *args, **kwargs):
                 # type: (RequestHandler, *Any, **Any) -> Any
-                hub = Hub.current
-                integration = hub.get_integration(TornadoIntegration)
-                if integration is None:
-                    return old_execute(self, *args, **kwargs)
-
-                weak_handler = weakref.ref(self)
-
-                with Hub(hub) as hub:
-                    with hub.configure_scope() as scope:
-                        scope.clear_breadcrumbs()
-                        processor = _make_event_processor(weak_handler)  # type: ignore
-                        scope.add_event_processor(processor)
+                with _handle_request_impl(self):
                     result = yield from old_execute(self, *args, **kwargs)
                     return result
 
-        RequestHandler._execute = sentry_execute_request_handler  # type: ignore
+        RequestHandler._execute = sentry_execute_request_handler
 
         old_log_exception = RequestHandler.log_exception
 
         def sentry_log_exception(self, ty, value, tb, *args, **kwargs):
             # type: (Any, type, BaseException, Any, *Any, **Any) -> Optional[Any]
             _capture_exception(ty, value, tb)
-            return old_log_exception(self, ty, value, tb, *args, **kwargs)  # type: ignore
+            return old_log_exception(self, ty, value, tb, *args, **kwargs)
+
+        RequestHandler.log_exception = sentry_log_exception
+
+
+@contextlib.contextmanager
+def _handle_request_impl(self):
+    # type: (RequestHandler) -> Generator[None, None, None]
+    integration = sentry_sdk.get_client().get_integration(TornadoIntegration)
 
-        RequestHandler.log_exception = sentry_log_exception  # type: ignore
+    if integration is None:
+        yield
 
+    weak_handler = weakref.ref(self)
 
+    with sentry_sdk.isolation_scope() as scope:
+        headers = self.request.headers
+
+        scope.clear_breadcrumbs()
+        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
+
+
+@ensure_integration_enabled(TornadoIntegration)
 def _capture_exception(ty, value, tb):
     # type: (type, BaseException, Any) -> None
-    hub = Hub.current
-    if hub.get_integration(TornadoIntegration) is None:
-        return
     if isinstance(value, HTTPError):
         return
 
-    # If an integration is there, a client has to be there.
-    client = hub.client  # type: Any
-
     event, hint = event_from_exception(
         (ty, value, tb),
-        client_options=client.options,
+        client_options=sentry_sdk.get_client().options,
         mechanism={"type": "tornado", "handled": False},
     )
 
-    hub.capture_event(event, hint=hint)
+    sentry_sdk.capture_event(event, hint=hint)
 
 
 def _make_event_processor(weak_handler):
     # type: (Callable[[], RequestHandler]) -> EventProcessor
     def tornado_processor(event, hint):
-        # type: (Dict[str, Any], Dict[str, Any]) -> Dict[str, Any]
+        # type: (Event, dict[str, Any]) -> Event
         handler = weak_handler()
         if handler is None:
             return event
@@ -141,8 +155,9 @@ def _make_event_processor(weak_handler):
         request = handler.request
 
         with capture_internal_exceptions():
-            method = getattr(handler, handler.request.method.lower())  # type: ignore
-            event["transaction"] = transaction_from_function(method)
+            method = getattr(handler, handler.request.method.lower())
+            event["transaction"] = transaction_from_function(method) or ""
+            event["transaction_info"] = {"source": TransactionSource.COMPONENT}
 
         with capture_internal_exceptions():
             extractor = TornadoRequestExtractor(request)
@@ -162,7 +177,7 @@ def _make_event_processor(weak_handler):
             request_info["headers"] = _filter_headers(dict(request.headers))
 
         with capture_internal_exceptions():
-            if handler.current_user and _should_send_default_pii():
+            if handler.current_user and should_send_default_pii():
                 event.setdefault("user", {}).setdefault("is_authenticated", True)
 
         return event
@@ -179,7 +194,7 @@ class TornadoRequestExtractor(RequestExtractor):
 
     def cookies(self):
         # type: () -> Dict[str, str]
-        return {k: v.value for k, v in iteritems(self.request.cookies)}
+        return {k: v.value for k, v in self.request.cookies.items()}
 
     def raw_data(self):
         # type: () -> bytes
@@ -189,7 +204,7 @@ class TornadoRequestExtractor(RequestExtractor):
         # type: () -> Dict[str, Any]
         return {
             k: [v.decode("latin1", "replace") for v in vs]
-            for k, vs in iteritems(self.request.body_arguments)
+            for k, vs in self.request.body_arguments.items()
         }
 
     def is_json(self):
@@ -198,7 +213,7 @@ class TornadoRequestExtractor(RequestExtractor):
 
     def files(self):
         # type: () -> Dict[str, Any]
-        return {k: v[0] for k, v in iteritems(self.request.files) if v}
+        return {k: v[0] for k, v in self.request.files.items() if v}
 
     def size_of_file(self, file):
         # type: (Any) -> int

sentry_sdk/integrations/trytond.py

@@ -1,46 +1,41 @@
-import sentry_sdk.hub
-import sentry_sdk.utils
-import sentry_sdk.integrations
-import sentry_sdk.integrations.wsgi
-from sentry_sdk._types import MYPY
+import sentry_sdk
+from sentry_sdk.integrations import Integration
+from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
+from sentry_sdk.utils import ensure_integration_enabled, event_from_exception
 
 from trytond.exceptions import TrytonException  # type: ignore
 from trytond.wsgi import app  # type: ignore
 
-if MYPY:
-    from typing import Any
-
 
 # TODO: trytond-worker, trytond-cron and trytond-admin intergations
 
 
-class TrytondWSGIIntegration(sentry_sdk.integrations.Integration):
+class TrytondWSGIIntegration(Integration):
     identifier = "trytond_wsgi"
+    origin = f"auto.http.{identifier}"
 
     def __init__(self):  # type: () -> None
         pass
 
     @staticmethod
     def setup_once():  # type: () -> None
+        app.wsgi_app = SentryWsgiMiddleware(
+            app.wsgi_app,
+            span_origin=TrytondWSGIIntegration.origin,
+        )
 
-        app.wsgi_app = sentry_sdk.integrations.wsgi.SentryWsgiMiddleware(app.wsgi_app)
-
+        @ensure_integration_enabled(TrytondWSGIIntegration)
         def error_handler(e):  # type: (Exception) -> None
-            hub = sentry_sdk.hub.Hub.current
-
-            if hub.get_integration(TrytondWSGIIntegration) is None:
-                return
-            elif isinstance(e, TrytonException):
+            if isinstance(e, TrytonException):
                 return
             else:
-                # If an integration is there, a client has to be there.
-                client = hub.client  # type: Any
-                event, hint = sentry_sdk.utils.event_from_exception(
+                client = sentry_sdk.get_client()
+                event, hint = event_from_exception(
                     e,
                     client_options=client.options,
                     mechanism={"type": "trytond", "handled": False},
                 )
-                hub.capture_event(event, hint=hint)
+                sentry_sdk.capture_event(event, hint=hint)
 
         # Expected error handlers signature was changed
         # when the error_handler decorator was introduced

sentry_sdk/integrations/typer.py

@@ -0,0 +1,60 @@
+import sentry_sdk
+from sentry_sdk.utils import (
+    capture_internal_exceptions,
+    event_from_exception,
+)
+from sentry_sdk.integrations import Integration, DidNotEnable
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Callable
+    from typing import Any
+    from typing import Type
+    from typing import Optional
+
+    from types import TracebackType
+
+    Excepthook = Callable[
+        [Type[BaseException], BaseException, Optional[TracebackType]],
+        Any,
+    ]
+
+try:
+    import typer
+except ImportError:
+    raise DidNotEnable("Typer not installed")
+
+
+class TyperIntegration(Integration):
+    identifier = "typer"
+
+    @staticmethod
+    def setup_once():
+        # type: () -> None
+        typer.main.except_hook = _make_excepthook(typer.main.except_hook)  # type: ignore
+
+
+def _make_excepthook(old_excepthook):
+    # type: (Excepthook) -> Excepthook
+    def sentry_sdk_excepthook(type_, value, traceback):
+        # type: (Type[BaseException], BaseException, Optional[TracebackType]) -> None
+        integration = sentry_sdk.get_client().get_integration(TyperIntegration)
+
+        # Note: If we replace this with ensure_integration_enabled then
+        # we break the exceptiongroup backport;
+        # See: https://github.com/getsentry/sentry-python/issues/3097
+        if integration is None:
+            return old_excepthook(type_, value, traceback)
+
+        with capture_internal_exceptions():
+            event, hint = event_from_exception(
+                (type_, value, traceback),
+                client_options=sentry_sdk.get_client().options,
+                mechanism={"type": "typer", "handled": False},
+            )
+            sentry_sdk.capture_event(event, hint=hint)
+
+        return old_excepthook(type_, value, traceback)
+
+    return sentry_sdk_excepthook

sentry_sdk/integrations/unleash.py

@@ -0,0 +1,33 @@
+from functools import wraps
+from typing import Any
+
+from sentry_sdk.feature_flags import add_feature_flag
+from sentry_sdk.integrations import Integration, DidNotEnable
+
+try:
+    from UnleashClient import UnleashClient
+except ImportError:
+    raise DidNotEnable("UnleashClient is not installed")
+
+
+class UnleashIntegration(Integration):
+    identifier = "unleash"
+
+    @staticmethod
+    def setup_once():
+        # type: () -> None
+        # Wrap and patch evaluation methods (class methods)
+        old_is_enabled = UnleashClient.is_enabled
+
+        @wraps(old_is_enabled)
+        def sentry_is_enabled(self, feature, *args, **kwargs):
+            # type: (UnleashClient, str, *Any, **Any) -> Any
+            enabled = old_is_enabled(self, feature, *args, **kwargs)
+
+            # We have no way of knowing what type of unleash feature this is, so we have to treat
+            # it as a boolean / toggle feature.
+            add_feature_flag(feature, enabled)
+
+            return enabled
+
+        UnleashClient.is_enabled = sentry_is_enabled  # type: ignore

sentry_sdk/integrations/unraisablehook.py

@@ -0,0 +1,53 @@
+import sys
+
+import sentry_sdk
+from sentry_sdk.utils import (
+    capture_internal_exceptions,
+    event_from_exception,
+)
+from sentry_sdk.integrations import Integration
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Callable
+    from typing import Any
+
+
+class UnraisablehookIntegration(Integration):
+    identifier = "unraisablehook"
+
+    @staticmethod
+    def setup_once():
+        # type: () -> None
+        sys.unraisablehook = _make_unraisable(sys.unraisablehook)
+
+
+def _make_unraisable(old_unraisablehook):
+    # type: (Callable[[sys.UnraisableHookArgs], Any]) -> Callable[[sys.UnraisableHookArgs], Any]
+    def sentry_sdk_unraisablehook(unraisable):
+        # type: (sys.UnraisableHookArgs) -> None
+        integration = sentry_sdk.get_client().get_integration(UnraisablehookIntegration)
+
+        # Note: If  we replace this with ensure_integration_enabled then
+        # we break the exceptiongroup backport;
+        # See: https://github.com/getsentry/sentry-python/issues/3097
+        if integration is None:
+            return old_unraisablehook(unraisable)
+
+        if unraisable.exc_value and unraisable.exc_traceback:
+            with capture_internal_exceptions():
+                event, hint = event_from_exception(
+                    (
+                        unraisable.exc_type,
+                        unraisable.exc_value,
+                        unraisable.exc_traceback,
+                    ),
+                    client_options=sentry_sdk.get_client().options,
+                    mechanism={"type": "unraisablehook", "handled": False},
+                )
+                sentry_sdk.capture_event(event, hint=hint)
+
+        return old_unraisablehook(unraisable)
+
+    return sentry_sdk_unraisablehook