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

sentry_sdk/integrations/django/signals_handlers.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from functools import wraps
 
 from django.dispatch import Signal
@@ -13,8 +14,7 @@ if TYPE_CHECKING:
     from typing import Any, Union
 
 
-def _get_receiver_name(receiver):
-    # type: (Callable[..., Any]) -> str
+def _get_receiver_name(receiver: Callable[..., Any]) -> str:
     name = ""
 
     if hasattr(receiver, "__qualname__"):
@@ -38,8 +38,7 @@ def _get_receiver_name(receiver):
     return name
 
 
-def patch_signals():
-    # type: () -> None
+def patch_signals() -> None:
     """
     Patch django signal receivers to create a span.
 
@@ -51,19 +50,21 @@ def patch_signals():
     old_live_receivers = Signal._live_receivers
 
     @wraps(old_live_receivers)
-    def _sentry_live_receivers(self, sender):
-        # type: (Signal, Any) -> Union[tuple[list[Callable[..., Any]], list[Callable[..., Any]]], list[Callable[..., Any]]]
+    def _sentry_live_receivers(self: Signal, sender: Any) -> Union[
+        tuple[list[Callable[..., Any]], list[Callable[..., Any]]],
+        list[Callable[..., Any]],
+    ]:
         if DJANGO_VERSION >= (5, 0):
             sync_receivers, async_receivers = old_live_receivers(self, sender)
         else:
             sync_receivers = old_live_receivers(self, sender)
             async_receivers = []
 
-        def sentry_sync_receiver_wrapper(receiver):
-            # type: (Callable[..., Any]) -> Callable[..., Any]
+        def sentry_sync_receiver_wrapper(
+            receiver: Callable[..., Any],
+        ) -> Callable[..., Any]:
             @wraps(receiver)
-            def wrapper(*args, **kwargs):
-                # type: (Any, Any) -> Any
+            def wrapper(*args: Any, **kwargs: Any) -> Any:
                 signal_name = _get_receiver_name(receiver)
                 with sentry_sdk.start_span(
                     op=OP.EVENT_DJANGO,

sentry_sdk/integrations/django/templates.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 
 from django.template import TemplateSyntaxError
@@ -18,8 +19,9 @@ if TYPE_CHECKING:
     from typing import Tuple
 
 
-def get_template_frame_from_exception(exc_value):
-    # type: (Optional[BaseException]) -> Optional[Dict[str, Any]]
+def get_template_frame_from_exception(
+    exc_value: Optional[BaseException],
+) -> Optional[Dict[str, Any]]:
 
     # As of Django 1.9 or so the new template debug thing showed up.
     if hasattr(exc_value, "template_debug"):
@@ -41,8 +43,7 @@ def get_template_frame_from_exception(exc_value):
     return None
 
 
-def _get_template_name_description(template_name):
-    # type: (str) -> str
+def _get_template_name_description(template_name: str) -> str:
     if isinstance(template_name, (list, tuple)):
         if template_name:
             return "[{}, ...]".format(template_name[0])
@@ -50,8 +51,7 @@ def _get_template_name_description(template_name):
         return template_name
 
 
-def patch_templates():
-    # type: () -> None
+def patch_templates() -> None:
     from django.template.response import SimpleTemplateResponse
     from sentry_sdk.integrations.django import DjangoIntegration
 
@@ -59,8 +59,7 @@ def patch_templates():
 
     @property  # type: ignore
     @ensure_integration_enabled(DjangoIntegration, real_rendered_content.fget)
-    def rendered_content(self):
-        # type: (SimpleTemplateResponse) -> str
+    def rendered_content(self: SimpleTemplateResponse) -> str:
         with sentry_sdk.start_span(
             op=OP.TEMPLATE_RENDER,
             name=_get_template_name_description(self.template_name),
@@ -80,8 +79,13 @@ def patch_templates():
 
     @functools.wraps(real_render)
     @ensure_integration_enabled(DjangoIntegration, real_render)
-    def render(request, template_name, context=None, *args, **kwargs):
-        # type: (django.http.HttpRequest, str, Optional[Dict[str, Any]], *Any, **Any) -> django.http.HttpResponse
+    def render(
+        request: django.http.HttpRequest,
+        template_name: str,
+        context: Optional[Dict[str, Any]] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> django.http.HttpResponse:
 
         # Inject trace meta tags into template context
         context = context or {}
@@ -103,8 +107,7 @@ def patch_templates():
     django.shortcuts.render = render
 
 
-def _get_template_frame_from_debug(debug):
-    # type: (Dict[str, Any]) -> Dict[str, Any]
+def _get_template_frame_from_debug(debug: Dict[str, Any]) -> Dict[str, Any]:
     if debug is None:
         return None
 
@@ -135,8 +138,7 @@ def _get_template_frame_from_debug(debug):
     }
 
 
-def _linebreak_iter(template_source):
-    # type: (str) -> Iterator[int]
+def _linebreak_iter(template_source: str) -> Iterator[int]:
     yield 0
     p = template_source.find("\n")
     while p >= 0:
@@ -144,8 +146,9 @@ def _linebreak_iter(template_source):
         p = template_source.find("\n", p + 1)
 
 
-def _get_template_frame_from_source(source):
-    # type: (Tuple[Origin, Tuple[int, int]]) -> Optional[Dict[str, Any]]
+def _get_template_frame_from_source(
+    source: Tuple[Origin, Tuple[int, int]],
+) -> Optional[Dict[str, Any]]:
     if not source:
         return None
 

sentry_sdk/integrations/django/transactions.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 Copied from raven-python.
 
@@ -27,8 +29,7 @@ except ImportError:
     from django.core.urlresolvers import get_resolver
 
 
-def get_regex(resolver_or_pattern):
-    # type: (Union[URLPattern, URLResolver]) -> Pattern[str]
+def get_regex(resolver_or_pattern: Union[URLPattern, URLResolver]) -> Pattern[str]:
     """Utility method for django's deprecated resolver.regex"""
     try:
         regex = resolver_or_pattern.regex
@@ -48,10 +49,9 @@ class RavenResolver:
     _either_option_matcher = re.compile(r"\[([^\]]+)\|([^\]]+)\]")
     _camel_re = re.compile(r"([A-Z]+)([a-z])")
 
-    _cache = {}  # type: Dict[URLPattern, str]
+    _cache: Dict[URLPattern, str] = {}
 
-    def _simplify(self, pattern):
-        # type: (Union[URLPattern, URLResolver]) -> str
+    def _simplify(self, pattern: Union[URLPattern, URLResolver]) -> str:
         r"""
         Clean up urlpattern regexes into something readable by humans:
 
@@ -102,8 +102,12 @@ class RavenResolver:
 
         return result
 
-    def _resolve(self, resolver, path, parents=None):
-        # type: (URLResolver, str, Optional[List[URLResolver]]) -> Optional[str]
+    def _resolve(
+        self,
+        resolver: URLResolver,
+        path: str,
+        parents: Optional[List[URLResolver]] = None,
+    ) -> Optional[str]:
 
         match = get_regex(resolver).search(path)  # Django < 2.0
 
@@ -142,10 +146,11 @@ class RavenResolver:
 
     def resolve(
         self,
-        path,  # type: str
-        urlconf=None,  # type: Union[None, Tuple[URLPattern, URLPattern, URLResolver], Tuple[URLPattern]]
-    ):
-        # type: (...) -> Optional[str]
+        path: str,
+        urlconf: Union[
+            None, Tuple[URLPattern, URLPattern, URLResolver], Tuple[URLPattern]
+        ] = None,
+    ) -> Optional[str]:
         resolver = get_resolver(urlconf)
         match = self._resolve(resolver, path)
         return match

sentry_sdk/integrations/django/views.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 
 import sentry_sdk
@@ -21,8 +22,7 @@ except (ImportError, SyntaxError):
     wrap_async_view = None  # type: ignore
 
 
-def patch_views():
-    # type: () -> None
+def patch_views() -> None:
 
     from django.core.handlers.base import BaseHandler
     from django.template.response import SimpleTemplateResponse
@@ -32,8 +32,7 @@ def patch_views():
     old_render = SimpleTemplateResponse.render
 
     @functools.wraps(old_render)
-    def sentry_patched_render(self):
-        # type: (SimpleTemplateResponse) -> Any
+    def sentry_patched_render(self: SimpleTemplateResponse) -> Any:
         with sentry_sdk.start_span(
             op=OP.VIEW_RESPONSE_RENDER,
             name="serialize response",
@@ -43,8 +42,7 @@ def patch_views():
             return old_render(self)
 
     @functools.wraps(old_make_view_atomic)
-    def sentry_patched_make_view_atomic(self, *args, **kwargs):
-        # type: (Any, *Any, **Any) -> Any
+    def sentry_patched_make_view_atomic(self: Any, *args: Any, **kwargs: Any) -> Any:
         callback = old_make_view_atomic(self, *args, **kwargs)
 
         # XXX: The wrapper function is created for every request. Find more
@@ -71,13 +69,11 @@ def patch_views():
     BaseHandler.make_view_atomic = sentry_patched_make_view_atomic
 
 
-def _wrap_sync_view(callback):
-    # type: (Any) -> Any
+def _wrap_sync_view(callback: Any) -> Any:
     from sentry_sdk.integrations.django import DjangoIntegration
 
     @functools.wraps(callback)
-    def sentry_wrapped_callback(request, *args, **kwargs):
-        # type: (Any, *Any, **Any) -> Any
+    def sentry_wrapped_callback(request: Any, *args: Any, **kwargs: Any) -> Any:
         current_scope = sentry_sdk.get_current_scope()
         if current_scope.root_span is not None:
             current_scope.root_span.update_active_thread()

sentry_sdk/integrations/dramatiq.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import json
 
 import sentry_sdk
@@ -36,17 +37,14 @@ class DramatiqIntegration(Integration):
     identifier = "dramatiq"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         _patch_dramatiq_broker()
 
 
-def _patch_dramatiq_broker():
-    # type: () -> None
+def _patch_dramatiq_broker() -> None:
     original_broker__init__ = Broker.__init__
 
-    def sentry_patched_broker__init__(self, *args, **kw):
-        # type: (Broker, *Any, **Any) -> None
+    def sentry_patched_broker__init__(self: Broker, *args: Any, **kw: Any) -> None:
         integration = sentry_sdk.get_client().get_integration(DramatiqIntegration)
 
         try:
@@ -85,8 +83,7 @@ class SentryMiddleware(Middleware):  # type: ignore[misc]
     DramatiqIntegration.
     """
 
-    def before_process_message(self, broker, message):
-        # type: (Broker, Message) -> None
+    def before_process_message(self, broker: Broker, message: Message) -> None:
         integration = sentry_sdk.get_client().get_integration(DramatiqIntegration)
         if integration is None:
             return
@@ -99,8 +96,14 @@ class SentryMiddleware(Middleware):  # type: ignore[misc]
         scope.set_extra("dramatiq_message_id", message.message_id)
         scope.add_event_processor(_make_message_event_processor(message, integration))
 
-    def after_process_message(self, broker, message, *, result=None, exception=None):
-        # type: (Broker, Message, Any, Optional[Any], Optional[Exception]) -> None
+    def after_process_message(
+        self: Broker,
+        broker: Message,
+        message: Any,
+        *,
+        result: Optional[Any] = None,
+        exception: Optional[Exception] = None,
+    ) -> None:
         integration = sentry_sdk.get_client().get_integration(DramatiqIntegration)
         if integration is None:
             return
@@ -127,11 +130,11 @@ class SentryMiddleware(Middleware):  # type: ignore[misc]
             message._scope_manager.__exit__(None, None, None)
 
 
-def _make_message_event_processor(message, integration):
-    # type: (Message, DramatiqIntegration) -> Callable[[Event, Hint], Optional[Event]]
+def _make_message_event_processor(
+    message: Message, integration: DramatiqIntegration
+) -> Callable[[Event, Hint], Optional[Event]]:
 
-    def inner(event, hint):
-        # type: (Event, Hint) -> Optional[Event]
+    def inner(event: Event, hint: Hint) -> Optional[Event]:
         with capture_internal_exceptions():
             DramatiqMessageExtractor(message).extract_into_event(event)
 
@@ -141,16 +144,13 @@ def _make_message_event_processor(message, integration):
 
 
 class DramatiqMessageExtractor:
-    def __init__(self, message):
-        # type: (Message) -> None
+    def __init__(self, message: Message) -> None:
         self.message_data = dict(message.asdict())
 
-    def content_length(self):
-        # type: () -> int
+    def content_length(self) -> int:
         return len(json.dumps(self.message_data))
 
-    def extract_into_event(self, event):
-        # type: (Event) -> None
+    def extract_into_event(self, event: Event) -> None:
         client = sentry_sdk.get_client()
         if not client.is_active():
             return
@@ -159,7 +159,7 @@ class DramatiqMessageExtractor:
         request_info = contexts.setdefault("dramatiq", {})
         request_info["type"] = "dramatiq"
 
-        data = None  # type: Optional[Union[AnnotatedValue, Dict[str, Any]]]
+        data: Optional[Union[AnnotatedValue, Dict[str, Any]]] = None
         if not request_body_within_bounds(client, self.content_length()):
             data = AnnotatedValue.removed_because_over_size_limit()
         else:

sentry_sdk/integrations/excepthook.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 
 import sentry_sdk
@@ -28,8 +29,7 @@ class ExcepthookIntegration(Integration):
 
     always_run = False
 
-    def __init__(self, always_run=False):
-        # type: (bool) -> None
+    def __init__(self, always_run: bool = False) -> None:
 
         if not isinstance(always_run, bool):
             raise ValueError(
@@ -39,15 +39,16 @@ class ExcepthookIntegration(Integration):
         self.always_run = always_run
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         sys.excepthook = _make_excepthook(sys.excepthook)
 
 
-def _make_excepthook(old_excepthook):
-    # type: (Excepthook) -> Excepthook
-    def sentry_sdk_excepthook(type_, value, traceback):
-        # type: (Type[BaseException], BaseException, Optional[TracebackType]) -> None
+def _make_excepthook(old_excepthook: Excepthook) -> Excepthook:
+    def sentry_sdk_excepthook(
+        type_: Type[BaseException],
+        value: BaseException,
+        traceback: Optional[TracebackType],
+    ) -> None:
         integration = sentry_sdk.get_client().get_integration(ExcepthookIntegration)
 
         # Note: If  we replace this with ensure_integration_enabled then
@@ -70,8 +71,7 @@ def _make_excepthook(old_excepthook):
     return sentry_sdk_excepthook
 
 
-def _should_send(always_run=False):
-    # type: (bool) -> bool
+def _should_send(always_run: bool = False) -> bool:
     if always_run:
         return True
 

sentry_sdk/integrations/executing.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.integrations import Integration, DidNotEnable
 from sentry_sdk.scope import add_global_event_processor
@@ -20,12 +21,10 @@ class ExecutingIntegration(Integration):
     identifier = "executing"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
 
         @add_global_event_processor
-        def add_executing_info(event, hint):
-            # type: (Event, Optional[Hint]) -> Optional[Event]
+        def add_executing_info(event: Event, hint: Optional[Hint]) -> Optional[Event]:
             if sentry_sdk.get_client().get_integration(ExecutingIntegration) is None:
                 return event
 

sentry_sdk/integrations/falcon.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.consts import SOURCE_FOR_STYLE
 from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
@@ -33,30 +34,25 @@ falcon_helpers = falcon.app_helpers
 falcon_app_class = falcon.App
 
 
-_FALCON_UNSET = None  # type: Optional[object]
+_FALCON_UNSET: Optional[object] = None
 with capture_internal_exceptions():
     from falcon.request import _UNSET as _FALCON_UNSET  # type: ignore[import-not-found, no-redef]
 
 
 class FalconRequestExtractor(RequestExtractor):
-    def env(self):
-        # type: () -> Dict[str, Any]
+    def env(self) -> Dict[str, Any]:
         return self.request.env
 
-    def cookies(self):
-        # type: () -> Dict[str, Any]
+    def cookies(self) -> Dict[str, Any]:
         return self.request.cookies
 
-    def form(self):
-        # type: () -> None
+    def form(self) -> None:
         return None  # No such concept in Falcon
 
-    def files(self):
-        # type: () -> None
+    def files(self) -> None:
         return None  # No such concept in Falcon
 
-    def raw_data(self):
-        # type: () -> Optional[str]
+    def raw_data(self) -> Optional[str]:
 
         # As request data can only be read once we won't make this available
         # to Sentry. Just send back a dummy string in case there was a
@@ -68,8 +64,7 @@ class FalconRequestExtractor(RequestExtractor):
         else:
             return None
 
-    def json(self):
-        # type: () -> Optional[Dict[str, Any]]
+    def json(self) -> Optional[Dict[str, Any]]:
         # fallback to cached_media = None if self.request._media is not available
         cached_media = None
         with capture_internal_exceptions():
@@ -90,8 +85,7 @@ class FalconRequestExtractor(RequestExtractor):
 class SentryFalconMiddleware:
     """Captures exceptions in Falcon requests and send to Sentry"""
 
-    def process_request(self, req, resp, *args, **kwargs):
-        # type: (Any, Any, *Any, **Any) -> None
+    def process_request(self, req: Any, resp: Any, *args: Any, **kwargs: Any) -> None:
         integration = sentry_sdk.get_client().get_integration(FalconIntegration)
         if integration is None:
             return
@@ -110,8 +104,7 @@ class FalconIntegration(Integration):
 
     transaction_style = ""
 
-    def __init__(self, transaction_style="uri_template"):
-        # type: (str) -> None
+    def __init__(self, transaction_style: str = "uri_template") -> None:
         if transaction_style not in TRANSACTION_STYLE_VALUES:
             raise ValueError(
                 "Invalid value for transaction_style: %s (must be in %s)"
@@ -120,8 +113,7 @@ class FalconIntegration(Integration):
         self.transaction_style = transaction_style
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
 
         version = parse_version(FALCON_VERSION)
         _check_minimum_version(FalconIntegration, version)
@@ -131,12 +123,10 @@ class FalconIntegration(Integration):
         _patch_prepare_middleware()
 
 
-def _patch_wsgi_app():
-    # type: () -> None
+def _patch_wsgi_app() -> None:
     original_wsgi_app = falcon_app_class.__call__
 
-    def sentry_patched_wsgi_app(self, env, start_response):
-        # type: (falcon.API, Any, Any) -> Any
+    def sentry_patched_wsgi_app(self: falcon.API, env: Any, start_response: Any) -> Any:
         integration = sentry_sdk.get_client().get_integration(FalconIntegration)
         if integration is None:
             return original_wsgi_app(self, env, start_response)
@@ -151,13 +141,11 @@ def _patch_wsgi_app():
     falcon_app_class.__call__ = sentry_patched_wsgi_app
 
 
-def _patch_handle_exception():
-    # type: () -> None
+def _patch_handle_exception() -> None:
     original_handle_exception = falcon_app_class._handle_exception
 
     @ensure_integration_enabled(FalconIntegration, original_handle_exception)
-    def sentry_patched_handle_exception(self, *args):
-        # type: (falcon.API, *Any) -> Any
+    def sentry_patched_handle_exception(self: falcon.API, *args: Any) -> Any:
         # NOTE(jmagnusson): falcon 2.0 changed falcon.API._handle_exception
         # method signature from `(ex, req, resp, params)` to
         # `(req, resp, ex, params)`
@@ -189,14 +177,12 @@ def _patch_handle_exception():
     falcon_app_class._handle_exception = sentry_patched_handle_exception
 
 
-def _patch_prepare_middleware():
-    # type: () -> None
+def _patch_prepare_middleware() -> None:
     original_prepare_middleware = falcon_helpers.prepare_middleware
 
     def sentry_patched_prepare_middleware(
-        middleware=None, independent_middleware=False, asgi=False
-    ):
-        # type: (Any, Any, bool) -> Any
+        middleware: Any = None, independent_middleware: Any = False, asgi: bool = False
+    ) -> Any:
         if asgi:
             # We don't support ASGI Falcon apps, so we don't patch anything here
             return original_prepare_middleware(middleware, independent_middleware, asgi)
@@ -212,8 +198,7 @@ def _patch_prepare_middleware():
     falcon_helpers.prepare_middleware = sentry_patched_prepare_middleware
 
 
-def _exception_leads_to_http_5xx(ex, response):
-    # type: (Exception, falcon.Response) -> bool
+def _exception_leads_to_http_5xx(ex: Exception, response: falcon.Response) -> bool:
     is_server_error = isinstance(ex, falcon.HTTPError) and (ex.status or "").startswith(
         "5"
     )
@@ -224,13 +209,13 @@ def _exception_leads_to_http_5xx(ex, response):
     return (is_server_error or is_unhandled_error) and _has_http_5xx_status(response)
 
 
-def _has_http_5xx_status(response):
-    # type: (falcon.Response) -> bool
+def _has_http_5xx_status(response: falcon.Response) -> bool:
     return response.status.startswith("5")
 
 
-def _set_transaction_name_and_source(event, transaction_style, request):
-    # type: (Event, str, falcon.Request) -> None
+def _set_transaction_name_and_source(
+    event: Event, transaction_style: str, request: falcon.Request
+) -> None:
     name_for_style = {
         "uri_template": request.uri_template,
         "path": request.path,
@@ -239,11 +224,11 @@ def _set_transaction_name_and_source(event, transaction_style, request):
     event["transaction_info"] = {"source": SOURCE_FOR_STYLE[transaction_style]}
 
 
-def _make_request_event_processor(req, integration):
-    # type: (falcon.Request, FalconIntegration) -> EventProcessor
+def _make_request_event_processor(
+    req: falcon.Request, integration: FalconIntegration
+) -> EventProcessor:
 
-    def event_processor(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+    def event_processor(event: Event, hint: dict[str, Any]) -> Event:
         _set_transaction_name_and_source(event, integration.transaction_style, req)
 
         with capture_internal_exceptions():

sentry_sdk/integrations/fastapi.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import asyncio
 from copy import deepcopy
 from functools import wraps
@@ -38,13 +39,13 @@ class FastApiIntegration(StarletteIntegration):
     identifier = "fastapi"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         patch_get_request_handler()
 
 
-def _set_transaction_name_and_source(scope, transaction_style, request):
-    # type: (sentry_sdk.Scope, str, Any) -> None
+def _set_transaction_name_and_source(
+    scope: sentry_sdk.Scope, transaction_style: str, request: Any
+) -> None:
     name = ""
 
     if transaction_style == "endpoint":
@@ -71,12 +72,10 @@ def _set_transaction_name_and_source(scope, transaction_style, request):
     )
 
 
-def patch_get_request_handler():
-    # type: () -> None
+def patch_get_request_handler() -> None:
     old_get_request_handler = fastapi.routing.get_request_handler
 
-    def _sentry_get_request_handler(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def _sentry_get_request_handler(*args: Any, **kwargs: Any) -> Any:
         dependant = kwargs.get("dependant")
         if (
             dependant
@@ -86,8 +85,7 @@ def patch_get_request_handler():
             old_call = dependant.call
 
             @wraps(old_call)
-            def _sentry_call(*args, **kwargs):
-                # type: (*Any, **Any) -> Any
+            def _sentry_call(*args: Any, **kwargs: Any) -> Any:
                 current_scope = sentry_sdk.get_current_scope()
                 if current_scope.root_span is not None:
                     current_scope.root_span.update_active_thread()
@@ -102,8 +100,7 @@ def patch_get_request_handler():
 
         old_app = old_get_request_handler(*args, **kwargs)
 
-        async def _sentry_app(*args, **kwargs):
-            # type: (*Any, **Any) -> Any
+        async def _sentry_app(*args: Any, **kwargs: Any) -> Any:
             integration = sentry_sdk.get_client().get_integration(FastApiIntegration)
             if integration is None:
                 return await old_app(*args, **kwargs)
@@ -117,10 +114,10 @@ def patch_get_request_handler():
             extractor = StarletteRequestExtractor(request)
             info = await extractor.extract_request_info()
 
-            def _make_request_event_processor(req, integration):
-                # type: (Any, Any) -> Callable[[Event, Dict[str, Any]], Event]
-                def event_processor(event, hint):
-                    # type: (Event, Dict[str, Any]) -> Event
+            def _make_request_event_processor(
+                req: Any, integration: Any
+            ) -> Callable[[Event, Dict[str, Any]], Event]:
+                def event_processor(event: Event, hint: Dict[str, Any]) -> Event:
 
                     # Extract information from request
                     request_info = event.get("request", {})