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

sentry_sdk/integrations/tornado.py

@@ -1,14 +1,21 @@
-import sys
 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
+from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
 from sentry_sdk.integrations._wsgi_common import (
     RequestExtractor,
     _filter_headers,
@@ -16,37 +23,42 @@ from sentry_sdk.integrations._wsgi_common import (
 )
 from sentry_sdk.integrations.logging import ignore_logger
 
-from tornado.web import RequestHandler, HTTPError  # type: ignore
-from tornado.gen import coroutine  # type: ignore
+try:
+    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")
 
-if False:
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
     from typing import Any
-    from typing import List
     from typing import Optional
     from typing import Dict
     from typing import Callable
+    from typing import Generator
+
+    from sentry_sdk._types import Event, EventProcessor
 
 
 class TornadoIntegration(Integration):
     identifier = "tornado"
+    origin = f"auto.http.{identifier}"
 
     @staticmethod
     def setup_once():
         # type: () -> None
-        import tornado  # type: ignore
-
-        tornado_version = getattr(tornado, "version_info", None)
-        if tornado_version is None or tornado_version < (5, 0):
-            raise RuntimeError("Tornado 5+ required")
+        _check_minimum_version(TornadoIntegration, TORNADO_VERSION)
 
-        if sys.version_info < (3, 7):
+        if not HAS_REAL_CONTEXTVARS:
             # Tornado is async. We better have contextvars or we're going to leak
             # state between requests.
-            raise RuntimeError(
-                "The tornado integration for Sentry requires Python 3.7+"
+            raise DidNotEnable(
+                "The tornado integration for Sentry requires Python 3.7+ or the aiocontextvars package"
+                + CONTEXTVARS_ERROR_MESSAGE
             )
 
-        ignore_logger("tornado.application")
         ignore_logger("tornado.access")
 
         old_execute = RequestHandler._execute
@@ -57,33 +69,16 @@ 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, *List, **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.add_event_processor(_make_event_processor(weak_handler))
+                # type: (RequestHandler, *Any, **Any) -> Any
+                with _handle_request_impl(self):
                     return await old_execute(self, *args, **kwargs)
 
         else:
 
             @coroutine  # type: ignore
             def sentry_execute_request_handler(self, *args, **kwargs):
-                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.add_event_processor(_make_event_processor(weak_handler))
+                # type: (RequestHandler, *Any, **Any) -> Any
+                with _handle_request_impl(self):
                     result = yield from old_execute(self, *args, **kwargs)
                     return result
 
@@ -99,27 +94,60 @@ class TornadoIntegration(Integration):
         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)
+
+    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
 
     event, hint = event_from_exception(
         (ty, value, tb),
-        client_options=hub.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]) -> Callable
+    # 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
@@ -128,7 +156,8 @@ def _make_event_processor(weak_handler):
 
         with capture_internal_exceptions():
             method = getattr(handler, handler.request.method.lower())
-            event["transaction"] = transaction_from_function(method)
+            event["transaction"] = transaction_from_function(method) or ""
+            event["transaction_info"] = {"source": TransactionSource.COMPONENT}
 
         with capture_internal_exceptions():
             extractor = TornadoRequestExtractor(request)
@@ -148,8 +177,8 @@ 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():
-                event.setdefault("user", {})["is_authenticated"] = True
+            if handler.current_user and should_send_default_pii():
+                event.setdefault("user", {}).setdefault("is_authenticated", True)
 
         return event
 
@@ -164,7 +193,7 @@ class TornadoRequestExtractor(RequestExtractor):
         return len(self.request.body)
 
     def cookies(self):
-        # type: () -> Dict
+        # type: () -> Dict[str, str]
         return {k: v.value for k, v in self.request.cookies.items()}
 
     def raw_data(self):
@@ -172,17 +201,20 @@ class TornadoRequestExtractor(RequestExtractor):
         return self.request.body
 
     def form(self):
-        # type: () -> Optional[Any]
-        # TODO: Where to get formdata and nothing else?
-        return None
+        # type: () -> Dict[str, Any]
+        return {
+            k: [v.decode("latin1", "replace") for v in vs]
+            for k, vs in self.request.body_arguments.items()
+        }
 
     def is_json(self):
         # type: () -> bool
         return _is_json_content_type(self.request.headers.get("content-type"))
 
     def files(self):
-        # type: () -> Dict
+        # type: () -> Dict[str, Any]
         return {k: v[0] for k, v in self.request.files.items() if v}
 
     def size_of_file(self, file):
+        # type: (Any) -> int
         return len(file.body or ())

sentry_sdk/integrations/trytond.py

@@ -0,0 +1,50 @@
+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
+
+
+# TODO: trytond-worker, trytond-cron and trytond-admin intergations
+
+
+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,
+        )
+
+        @ensure_integration_enabled(TrytondWSGIIntegration)
+        def error_handler(e):  # type: (Exception) -> None
+            if isinstance(e, TrytonException):
+                return
+            else:
+                client = sentry_sdk.get_client()
+                event, hint = event_from_exception(
+                    e,
+                    client_options=client.options,
+                    mechanism={"type": "trytond", "handled": False},
+                )
+                sentry_sdk.capture_event(event, hint=hint)
+
+        # Expected error handlers signature was changed
+        # when the error_handler decorator was introduced
+        # in Tryton-5.4
+        if hasattr(app, "error_handler"):
+
+            @app.error_handler
+            def _(app, request, e):  # type: ignore
+                error_handler(e)
+
+        else:
+            app.error_handlers.append(error_handler)

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