sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a3__py2.py3-none-any.whl

sentry_sdk/integrations/arq.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 
 import sentry_sdk
@@ -45,8 +46,7 @@ class ArqIntegration(Integration):
     origin = f"auto.queue.{identifier}"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
 
         try:
             if isinstance(ARQ_VERSION, str):
@@ -66,13 +66,13 @@ class ArqIntegration(Integration):
         ignore_logger("arq.worker")
 
 
-def patch_enqueue_job():
-    # type: () -> None
+def patch_enqueue_job() -> None:
     old_enqueue_job = ArqRedis.enqueue_job
     original_kwdefaults = old_enqueue_job.__kwdefaults__
 
-    async def _sentry_enqueue_job(self, function, *args, **kwargs):
-        # type: (ArqRedis, str, *Any, **Any) -> Optional[Job]
+    async def _sentry_enqueue_job(
+        self: ArqRedis, function: str, *args: Any, **kwargs: Any
+    ) -> Optional[Job]:
         integration = sentry_sdk.get_client().get_integration(ArqIntegration)
         if integration is None:
             return await old_enqueue_job(self, function, *args, **kwargs)
@@ -89,12 +89,10 @@ def patch_enqueue_job():
     ArqRedis.enqueue_job = _sentry_enqueue_job
 
 
-def patch_run_job():
-    # type: () -> None
+def patch_run_job() -> None:
     old_run_job = Worker.run_job
 
-    async def _sentry_run_job(self, job_id, score):
-        # type: (Worker, str, int) -> None
+    async def _sentry_run_job(self: Worker, job_id: str, score: int) -> None:
         integration = sentry_sdk.get_client().get_integration(ArqIntegration)
         if integration is None:
             return await old_run_job(self, job_id, score)
@@ -123,8 +121,7 @@ def patch_run_job():
     Worker.run_job = _sentry_run_job
 
 
-def _capture_exception(exc_info):
-    # type: (ExcInfo) -> None
+def _capture_exception(exc_info: ExcInfo) -> None:
     scope = sentry_sdk.get_current_scope()
 
     if scope.root_span is not None:
@@ -142,10 +139,10 @@ def _capture_exception(exc_info):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _make_event_processor(ctx, *args, **kwargs):
-    # type: (Dict[Any, Any], *Any, **Any) -> EventProcessor
-    def event_processor(event, hint):
-        # type: (Event, Hint) -> Optional[Event]
+def _make_event_processor(
+    ctx: Dict[Any, Any], *args: Any, **kwargs: Any
+) -> EventProcessor:
+    def event_processor(event: Event, hint: Hint) -> Optional[Event]:
 
         with capture_internal_exceptions():
             scope = sentry_sdk.get_current_scope()
@@ -173,11 +170,9 @@ def _make_event_processor(ctx, *args, **kwargs):
     return event_processor
 
 
-def _wrap_coroutine(name, coroutine):
-    # type: (str, WorkerCoroutine) -> WorkerCoroutine
+def _wrap_coroutine(name: str, coroutine: WorkerCoroutine) -> WorkerCoroutine:
 
-    async def _sentry_coroutine(ctx, *args, **kwargs):
-        # type: (Dict[Any, Any], *Any, **Any) -> Any
+    async def _sentry_coroutine(ctx: Dict[Any, Any], *args: Any, **kwargs: Any) -> Any:
         integration = sentry_sdk.get_client().get_integration(ArqIntegration)
         if integration is None:
             return await coroutine(ctx, *args, **kwargs)
@@ -198,13 +193,11 @@ def _wrap_coroutine(name, coroutine):
     return _sentry_coroutine
 
 
-def patch_create_worker():
-    # type: () -> None
+def patch_create_worker() -> None:
     old_create_worker = arq.worker.create_worker
 
     @ensure_integration_enabled(ArqIntegration, old_create_worker)
-    def _sentry_create_worker(*args, **kwargs):
-        # type: (*Any, **Any) -> Worker
+    def _sentry_create_worker(*args: Any, **kwargs: Any) -> Worker:
         settings_cls = args[0]
 
         if isinstance(settings_cls, dict):
@@ -225,7 +218,8 @@ def patch_create_worker():
             ]
         if hasattr(settings_cls, "cron_jobs"):
             settings_cls.cron_jobs = [
-                _get_arq_cron_job(cron_job) for cron_job in settings_cls.cron_jobs
+                _get_arq_cron_job(cron_job)
+                for cron_job in (settings_cls.cron_jobs or [])
             ]
 
         if "functions" in kwargs:
@@ -242,16 +236,14 @@ def patch_create_worker():
     arq.worker.create_worker = _sentry_create_worker
 
 
-def _get_arq_function(func):
-    # type: (Union[str, Function, WorkerCoroutine]) -> Function
+def _get_arq_function(func: Union[str, Function, WorkerCoroutine]) -> Function:
     arq_func = arq.worker.func(func)
     arq_func.coroutine = _wrap_coroutine(arq_func.name, arq_func.coroutine)
 
     return arq_func
 
 
-def _get_arq_cron_job(cron_job):
-    # type: (CronJob) -> CronJob
+def _get_arq_cron_job(cron_job: CronJob) -> CronJob:
     cron_job.coroutine = _wrap_coroutine(cron_job.name, cron_job.coroutine)
 
     return cron_job

sentry_sdk/integrations/asgi.py

@@ -4,6 +4,7 @@ An ASGI middleware.
 Based on Tom Christie's `sentry-asgi <https://github.com/encode/sentry-asgi>`.
 """
 
+from __future__ import annotations
 import asyncio
 import inspect
 from copy import deepcopy
@@ -61,8 +62,7 @@ ASGI_SCOPE_PROPERTY_TO_ATTRIBUTE = {
 }
 
 
-def _capture_exception(exc, mechanism_type="asgi"):
-    # type: (Any, str) -> None
+def _capture_exception(exc: Any, mechanism_type: str = "asgi") -> None:
 
     event, hint = event_from_exception(
         exc,
@@ -72,8 +72,7 @@ def _capture_exception(exc, mechanism_type="asgi"):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _looks_like_asgi3(app):
-    # type: (Any) -> bool
+def _looks_like_asgi3(app: Any) -> bool:
     """
     Try to figure out if an application object supports ASGI3.
 
@@ -100,14 +99,13 @@ class SentryAsgiMiddleware:
 
     def __init__(
         self,
-        app,  # type: Any
-        unsafe_context_data=False,  # type: bool
-        transaction_style="endpoint",  # type: str
-        mechanism_type="asgi",  # type: str
-        span_origin=None,  # type: Optional[str]
-        http_methods_to_capture=DEFAULT_HTTP_METHODS_TO_CAPTURE,  # type: Tuple[str, ...]
-    ):
-        # type: (...) -> None
+        app: Any,
+        unsafe_context_data: bool = False,
+        transaction_style: str = "endpoint",
+        mechanism_type: str = "asgi",
+        span_origin: Optional[str] = None,
+        http_methods_to_capture: Tuple[str, ...] = DEFAULT_HTTP_METHODS_TO_CAPTURE,
+    ) -> None:
         """
         Instrument an ASGI application with Sentry. Provides HTTP/websocket
         data to sent events and basic handling for exceptions bubbling up
@@ -145,24 +143,41 @@ class SentryAsgiMiddleware:
         self.http_methods_to_capture = http_methods_to_capture
 
         if _looks_like_asgi3(app):
-            self.__call__ = self._run_asgi3  # type: Callable[..., Any]
+            self.__call__: Callable[..., Any] = self._run_asgi3
         else:
             self.__call__ = self._run_asgi2
 
-    def _run_asgi2(self, scope):
-        # type: (Any) -> Any
-        async def inner(receive, send):
-            # type: (Any, Any) -> Any
+    def _capture_lifespan_exception(self, exc: Exception) -> None:
+        """Capture exceptions raise in application lifespan handlers.
+
+        The separate function is needed to support overriding in derived integrations that use different catching mechanisms.
+        """
+        return _capture_exception(exc=exc, mechanism_type=self.mechanism_type)
+
+    def _capture_request_exception(self, exc: Exception) -> None:
+        """Capture exceptions raised in incoming request handlers.
+
+        The separate function is needed to support overriding in derived integrations that use different catching mechanisms.
+        """
+        return _capture_exception(exc=exc, mechanism_type=self.mechanism_type)
+
+    def _run_asgi2(self, scope: Any) -> Any:
+        async def inner(receive: Any, send: Any) -> Any:
             return await self._run_app(scope, receive, send, asgi_version=2)
 
         return inner
 
-    async def _run_asgi3(self, scope, receive, send):
-        # type: (Any, Any, Any) -> Any
+    async def _run_asgi3(self, scope: Any, receive: Any, send: Any) -> Any:
         return await self._run_app(scope, receive, send, asgi_version=3)
 
-    async def _run_original_app(self, scope, receive, send, asgi_version):
-        # type: (Any, Any, Any, Any, int) -> Any
+    async def _run_original_app(
+        self,
+        scope: Any,
+        receive: Any,
+        send: Any,
+        asgi_version: Any,
+        is_lifespan: int = False,
+    ) -> Any:
         try:
             if asgi_version == 2:
                 return await self.app(scope)(receive, send)
@@ -170,15 +185,21 @@ class SentryAsgiMiddleware:
                 return await self.app(scope, receive, send)
 
         except Exception as exc:
-            _capture_exception(exc, mechanism_type=self.mechanism_type)
+            if is_lifespan:
+                self._capture_lifespan_exception(exc)
+            else:
+                self._capture_request_exception(exc)
             raise exc from None
 
-    async def _run_app(self, scope, receive, send, asgi_version):
-        # type: (Any, Any, Any, Any, int) -> Any
+    async def _run_app(
+        self, scope: Any, receive: Any, send: Any, asgi_version: int
+    ) -> Any:
         is_recursive_asgi_middleware = _asgi_middleware_applied.get(False)
         is_lifespan = scope["type"] == "lifespan"
         if is_recursive_asgi_middleware or is_lifespan:
-            return await self._run_original_app(scope, receive, send, asgi_version)
+            return await self._run_original_app(
+                scope, receive, send, asgi_version, is_lifespan
+            )
 
         _asgi_middleware_applied.set(True)
         try:
@@ -228,8 +249,9 @@ class SentryAsgiMiddleware:
                                 logger.debug("[ASGI] Started transaction: %s", span)
                                 span.set_tag("asgi.type", ty)
 
-                            async def _sentry_wrapped_send(event):
-                                # type: (Dict[str, Any]) -> Any
+                            async def _sentry_wrapped_send(
+                                event: Dict[str, Any],
+                            ) -> Any:
                                 is_http_response = (
                                     event.get("type") == "http.response.start"
                                     and span is not None
@@ -241,13 +263,18 @@ class SentryAsgiMiddleware:
                                 return await send(event)
 
                             return await self._run_original_app(
-                                scope, receive, _sentry_wrapped_send, asgi_version
+                                scope,
+                                receive,
+                                _sentry_wrapped_send,
+                                asgi_version,
+                                is_lifespan,
                             )
         finally:
             _asgi_middleware_applied.set(False)
 
-    def event_processor(self, event, hint, asgi_scope):
-        # type: (Event, Hint, Any) -> Optional[Event]
+    def event_processor(
+        self, event: Event, hint: Hint, asgi_scope: Any
+    ) -> Optional[Event]:
         request_data = event.get("request", {})
         request_data.update(_get_request_data(asgi_scope))
         event["request"] = deepcopy(request_data)
@@ -286,11 +313,11 @@ class SentryAsgiMiddleware:
     # data to your liking it's recommended to use the `before_send` callback
     # for that.
 
-    def _get_transaction_name_and_source(self, transaction_style, asgi_scope):
-        # type: (SentryAsgiMiddleware, str, Any) -> Tuple[str, str]
+    def _get_transaction_name_and_source(
+        self: SentryAsgiMiddleware, transaction_style: str, asgi_scope: Any
+    ) -> Tuple[str, str]:
         name = None
         source = SOURCE_FOR_STYLE[transaction_style]
-        ty = asgi_scope.get("type")
 
         if transaction_style == "endpoint":
             endpoint = asgi_scope.get("endpoint")
@@ -300,7 +327,7 @@ class SentryAsgiMiddleware:
             if endpoint:
                 name = transaction_from_function(endpoint) or ""
             else:
-                name = _get_url(asgi_scope, "http" if ty == "http" else "ws", host=None)
+                name = _get_url(asgi_scope)
                 source = TransactionSource.URL
 
         elif transaction_style == "url":
@@ -312,7 +339,7 @@ class SentryAsgiMiddleware:
                 if path is not None:
                     name = path
             else:
-                name = _get_url(asgi_scope, "http" if ty == "http" else "ws", host=None)
+                name = _get_url(asgi_scope)
                 source = TransactionSource.URL
 
         if name is None:
@@ -323,8 +350,7 @@ class SentryAsgiMiddleware:
         return name, source
 
 
-def _prepopulate_attributes(scope):
-    # type: (Any) -> dict[str, Any]
+def _prepopulate_attributes(scope: Any) -> dict[str, Any]:
     """Unpack ASGI scope into serializable OTel attributes."""
     scope = scope or {}
 

sentry_sdk/integrations/asyncio.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 
 import sentry_sdk
@@ -11,7 +12,7 @@ try:
 except ImportError:
     raise DidNotEnable("asyncio not available")
 
-from typing import cast, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Any
@@ -20,8 +21,7 @@ if TYPE_CHECKING:
     from sentry_sdk._types import ExcInfo
 
 
-def get_name(coro):
-    # type: (Any) -> str
+def get_name(coro: Any) -> str:
     return (
         getattr(coro, "__qualname__", None)
         or getattr(coro, "__name__", None)
@@ -29,18 +29,19 @@ def get_name(coro):
     )
 
 
-def patch_asyncio():
-    # type: () -> None
+def patch_asyncio() -> None:
     orig_task_factory = None
     try:
         loop = asyncio.get_running_loop()
         orig_task_factory = loop.get_task_factory()
 
-        def _sentry_task_factory(loop, coro, **kwargs):
-            # type: (asyncio.AbstractEventLoop, Coroutine[Any, Any, Any], Any) -> asyncio.Future[Any]
+        def _sentry_task_factory(
+            loop: asyncio.AbstractEventLoop,
+            coro: Coroutine[Any, Any, Any],
+            **kwargs: Any,
+        ) -> asyncio.Future[Any]:
 
-            async def _task_with_sentry_span_creation():
-                # type: () -> Any
+            async def _task_with_sentry_span_creation() -> Any:
                 result = None
 
                 with sentry_sdk.isolation_scope():
@@ -79,9 +80,8 @@ def patch_asyncio():
 
             # Set the task name to include the original coroutine's name
             try:
-                cast("asyncio.Task[Any]", task).set_name(
-                    f"{get_name(coro)} (Sentry-wrapped)"
-                )
+                if isinstance(task, asyncio.Task):
+                    task.set_name(f"{get_name(coro)} (Sentry-wrapped)")
             except AttributeError:
                 # set_name might not be available in all Python versions
                 pass
@@ -100,8 +100,7 @@ def patch_asyncio():
         )
 
 
-def _capture_exception():
-    # type: () -> ExcInfo
+def _capture_exception() -> ExcInfo:
     exc_info = sys.exc_info()
 
     client = sentry_sdk.get_client()
@@ -123,6 +122,5 @@ class AsyncioIntegration(Integration):
     origin = f"auto.function.{identifier}"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         patch_asyncio()

sentry_sdk/integrations/atexit.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import sys
 import atexit
@@ -12,15 +13,13 @@ if TYPE_CHECKING:
     from typing import Optional
 
 
-def default_callback(pending, timeout):
-    # type: (int, int) -> None
+def default_callback(pending: int, timeout: int) -> None:
     """This is the default shutdown callback that is set on the options.
     It prints out a message to stderr that informs the user that some events
     are still pending and the process is waiting for them to flush out.
     """
 
-    def echo(msg):
-        # type: (str) -> None
+    def echo(msg: str) -> None:
         sys.stderr.write(msg + "\n")
 
     echo("Sentry is attempting to send %i pending events" % pending)
@@ -32,18 +31,15 @@ def default_callback(pending, timeout):
 class AtexitIntegration(Integration):
     identifier = "atexit"
 
-    def __init__(self, callback=None):
-        # type: (Optional[Any]) -> None
+    def __init__(self, callback: Optional[Any] = None) -> None:
         if callback is None:
             callback = default_callback
         self.callback = callback
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         @atexit.register
-        def _shutdown():
-            # type: () -> None
+        def _shutdown() -> None:
             client = sentry_sdk.get_client()
             integration = client.get_integration(AtexitIntegration)
 

sentry_sdk/integrations/aws_lambda.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 import json
 import re
@@ -54,11 +55,9 @@ CONTEXT_TO_ATTRIBUTES = {
 }
 
 
-def _wrap_init_error(init_error):
-    # type: (F) -> F
+def _wrap_init_error(init_error: F) -> F:
     @ensure_integration_enabled(AwsLambdaIntegration, init_error)
-    def sentry_init_error(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def sentry_init_error(*args: Any, **kwargs: Any) -> Any:
         client = sentry_sdk.get_client()
 
         with capture_internal_exceptions():
@@ -86,11 +85,11 @@ def _wrap_init_error(init_error):
     return sentry_init_error  # type: ignore
 
 
-def _wrap_handler(handler):
-    # type: (F) -> F
+def _wrap_handler(handler: F) -> F:
     @functools.wraps(handler)
-    def sentry_handler(aws_event, aws_context, *args, **kwargs):
-        # type: (Any, Any, *Any, **Any) -> Any
+    def sentry_handler(
+        aws_event: Any, aws_context: Any, *args: Any, **kwargs: Any
+    ) -> Any:
 
         # Per https://docs.aws.amazon.com/lambda/latest/dg/python-handler.html,
         # `event` here is *likely* a dictionary, but also might be a number of
@@ -192,8 +191,7 @@ def _wrap_handler(handler):
     return sentry_handler  # type: ignore
 
 
-def _drain_queue():
-    # type: () -> None
+def _drain_queue() -> None:
     with capture_internal_exceptions():
         client = sentry_sdk.get_client()
         integration = client.get_integration(AwsLambdaIntegration)
@@ -207,13 +205,11 @@ class AwsLambdaIntegration(Integration):
     identifier = "aws_lambda"
     origin = f"auto.function.{identifier}"
 
-    def __init__(self, timeout_warning=False):
-        # type: (bool) -> None
+    def __init__(self, timeout_warning: bool = False) -> None:
         self.timeout_warning = timeout_warning
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
 
         lambda_bootstrap = get_lambda_bootstrap()
         if not lambda_bootstrap:
@@ -249,10 +245,8 @@ class AwsLambdaIntegration(Integration):
         # Patch the runtime client to drain the queue. This should work
         # even when the SDK is initialized inside of the handler
 
-        def _wrap_post_function(f):
-            # type: (F) -> F
-            def inner(*args, **kwargs):
-                # type: (*Any, **Any) -> Any
+        def _wrap_post_function(f: F) -> F:
+            def inner(*args: Any, **kwargs: Any) -> Any:
                 _drain_queue()
                 return f(*args, **kwargs)
 
@@ -270,8 +264,7 @@ class AwsLambdaIntegration(Integration):
         )
 
 
-def get_lambda_bootstrap():
-    # type: () -> Optional[Any]
+def get_lambda_bootstrap() -> Optional[Any]:
 
     # Python 3.7: If the bootstrap module is *already imported*, it is the
     # one we actually want to use (no idea what's in __main__)
@@ -307,12 +300,14 @@ def get_lambda_bootstrap():
         return None
 
 
-def _make_request_event_processor(aws_event, aws_context, configured_timeout):
-    # type: (Any, Any, Any) -> EventProcessor
+def _make_request_event_processor(
+    aws_event: Any, aws_context: Any, configured_timeout: Any
+) -> EventProcessor:
     start_time = datetime.now(timezone.utc)
 
-    def event_processor(sentry_event, hint, start_time=start_time):
-        # type: (Event, Hint, datetime) -> Optional[Event]
+    def event_processor(
+        sentry_event: Event, hint: Hint, start_time: datetime = start_time
+    ) -> Optional[Event]:
         remaining_time_in_milis = aws_context.get_remaining_time_in_millis()
         exec_duration = configured_timeout - remaining_time_in_milis
 
@@ -375,8 +370,7 @@ def _make_request_event_processor(aws_event, aws_context, configured_timeout):
     return event_processor
 
 
-def _get_url(aws_event, aws_context):
-    # type: (Any, Any) -> str
+def _get_url(aws_event: Any, aws_context: Any) -> str:
     path = aws_event.get("path", None)
 
     headers = aws_event.get("headers")
@@ -392,8 +386,7 @@ def _get_url(aws_event, aws_context):
     return "awslambda:///{}".format(aws_context.function_name)
 
 
-def _get_cloudwatch_logs_url(aws_context, start_time):
-    # type: (Any, datetime) -> str
+def _get_cloudwatch_logs_url(aws_context: Any, start_time: datetime) -> str:
     """
     Generates a CloudWatchLogs console URL based on the context object
 
@@ -424,8 +417,7 @@ def _get_cloudwatch_logs_url(aws_context, start_time):
     return url
 
 
-def _parse_formatted_traceback(formatted_tb):
-    # type: (list[str]) -> list[dict[str, Any]]
+def _parse_formatted_traceback(formatted_tb: list[str]) -> list[dict[str, Any]]:
     frames = []
     for frame in formatted_tb:
         match = re.match(r'File "(.+)", line (\d+), in (.+)', frame.strip())
@@ -446,8 +438,7 @@ def _parse_formatted_traceback(formatted_tb):
     return frames
 
 
-def _event_from_error_json(error_json):
-    # type: (dict[str, Any]) -> Event
+def _event_from_error_json(error_json: dict[str, Any]) -> Event:
     """
     Converts the error JSON from AWS Lambda into a Sentry error event.
     This is not a full fletched event, but better than nothing.
@@ -455,7 +446,7 @@ def _event_from_error_json(error_json):
     This is an example of where AWS creates the error JSON:
     https://github.com/aws/aws-lambda-python-runtime-interface-client/blob/2.2.1/awslambdaric/bootstrap.py#L479
     """
-    event = {
+    event: Event = {
         "level": "error",
         "exception": {
             "values": [
@@ -474,13 +465,12 @@ def _event_from_error_json(error_json):
                 }
             ],
         },
-    }  # type: Event
+    }
 
     return event
 
 
-def _prepopulate_attributes(aws_event, aws_context):
-    # type: (Any, Any) -> dict[str, Any]
+def _prepopulate_attributes(aws_event: Any, aws_context: Any) -> dict[str, Any]:
     attributes = {
         "cloud.provider": "aws",
     }