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

sentry_sdk/integrations/beam.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 import types
 from functools import wraps
@@ -35,8 +36,7 @@ class BeamIntegration(Integration):
     identifier = "beam"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         from apache_beam.transforms.core import DoFn, ParDo  # type: ignore
 
         ignore_logger("root")
@@ -52,8 +52,7 @@ class BeamIntegration(Integration):
 
         old_init = ParDo.__init__
 
-        def sentry_init_pardo(self, fn, *args, **kwargs):
-            # type: (ParDo, Any, *Any, **Any) -> Any
+        def sentry_init_pardo(self: ParDo, fn: Any, *args: Any, **kwargs: Any) -> Any:
             # Do not monkey patch init twice
             if not getattr(self, "_sentry_is_patched", False):
                 for func_name in function_patches:
@@ -79,14 +78,12 @@ class BeamIntegration(Integration):
         ParDo.__init__ = sentry_init_pardo
 
 
-def _wrap_inspect_call(cls, func_name):
-    # type: (Any, Any) -> Any
+def _wrap_inspect_call(cls: Any, func_name: Any) -> Any:
 
     if not hasattr(cls, func_name):
         return None
 
-    def _inspect(self):
-        # type: (Any) -> Any
+    def _inspect(self: Any) -> Any:
         """
         Inspect function overrides the way Beam gets argspec.
         """
@@ -113,15 +110,13 @@ def _wrap_inspect_call(cls, func_name):
     return _inspect
 
 
-def _wrap_task_call(func):
-    # type: (F) -> F
+def _wrap_task_call(func: F) -> F:
     """
     Wrap task call with a try catch to get exceptions.
     """
 
     @wraps(func)
-    def _inner(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def _inner(*args: Any, **kwargs: Any) -> Any:
         try:
             gen = func(*args, **kwargs)
         except Exception:
@@ -136,8 +131,7 @@ def _wrap_task_call(func):
 
 
 @ensure_integration_enabled(BeamIntegration)
-def _capture_exception(exc_info):
-    # type: (ExcInfo) -> None
+def _capture_exception(exc_info: ExcInfo) -> None:
     """
     Send Beam exception to Sentry.
     """
@@ -151,8 +145,7 @@ def _capture_exception(exc_info):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def raise_exception():
-    # type: () -> None
+def raise_exception() -> None:
     """
     Raise an exception.
     """
@@ -162,8 +155,7 @@ def raise_exception():
     reraise(*exc_info)
 
 
-def _wrap_generator_call(gen):
-    # type: (Iterator[T]) -> Iterator[T]
+def _wrap_generator_call(gen: Iterator[T]) -> Iterator[T]:
     """
     Wrap the generator to handle any failures.
     """

sentry_sdk/integrations/boto3.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from functools import partial
 
 import sentry_sdk
@@ -34,15 +35,15 @@ class Boto3Integration(Integration):
     origin = f"auto.http.{identifier}"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         version = parse_version(BOTOCORE_VERSION)
         _check_minimum_version(Boto3Integration, version, "botocore")
 
         orig_init = BaseClient.__init__
 
-        def sentry_patched_init(self, *args, **kwargs):
-            # type: (Type[BaseClient], *Any, **Any) -> None
+        def sentry_patched_init(
+            self: Type[BaseClient], *args: Any, **kwargs: Any
+        ) -> None:
             orig_init(self, *args, **kwargs)
             meta = self.meta
             service_id = meta.service_model.service_id.hyphenize()
@@ -57,8 +58,9 @@ class Boto3Integration(Integration):
 
 
 @ensure_integration_enabled(Boto3Integration)
-def _sentry_request_created(service_id, request, operation_name, **kwargs):
-    # type: (str, AWSRequest, str, **Any) -> None
+def _sentry_request_created(
+    service_id: str, request: AWSRequest, operation_name: str, **kwargs: Any
+) -> None:
     description = "aws.%s.%s" % (service_id, operation_name)
     span = sentry_sdk.start_span(
         op=OP.HTTP_CLIENT,
@@ -92,9 +94,10 @@ def _sentry_request_created(service_id, request, operation_name, **kwargs):
     request.context["_sentrysdk_span_data"] = data
 
 
-def _sentry_after_call(context, parsed, **kwargs):
-    # type: (Dict[str, Any], Dict[str, Any], **Any) -> None
-    span = context.pop("_sentrysdk_span", None)  # type: Optional[Span]
+def _sentry_after_call(
+    context: Dict[str, Any], parsed: Dict[str, Any], **kwargs: Any
+) -> None:
+    span: Optional[Span] = context.pop("_sentrysdk_span", None)
 
     # Span could be absent if the integration is disabled.
     if span is None:
@@ -122,8 +125,7 @@ def _sentry_after_call(context, parsed, **kwargs):
 
     orig_read = body.read
 
-    def sentry_streaming_body_read(*args, **kwargs):
-        # type: (*Any, **Any) -> bytes
+    def sentry_streaming_body_read(*args: Any, **kwargs: Any) -> bytes:
         try:
             ret = orig_read(*args, **kwargs)
             if not ret:
@@ -137,8 +139,7 @@ def _sentry_after_call(context, parsed, **kwargs):
 
     orig_close = body.close
 
-    def sentry_streaming_body_close(*args, **kwargs):
-        # type: (*Any, **Any) -> None
+    def sentry_streaming_body_close(*args: Any, **kwargs: Any) -> None:
         streaming_span.finish()
         orig_close(*args, **kwargs)
 
@@ -147,9 +148,10 @@ def _sentry_after_call(context, parsed, **kwargs):
     span.__exit__(None, None, None)
 
 
-def _sentry_after_call_error(context, exception, **kwargs):
-    # type: (Dict[str, Any], Type[BaseException], **Any) -> None
-    span = context.pop("_sentrysdk_span", None)  # type: Optional[Span]
+def _sentry_after_call_error(
+    context: Dict[str, Any], exception: Type[BaseException], **kwargs: Any
+) -> None:
+    span: Optional[Span] = context.pop("_sentrysdk_span", None)
 
     # Span could be absent if the integration is disabled.
     if span is None:

sentry_sdk/integrations/bottle.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 
 import sentry_sdk
@@ -55,11 +56,10 @@ class BottleIntegration(Integration):
 
     def __init__(
         self,
-        transaction_style="endpoint",  # type: str
+        transaction_style: str = "endpoint",
         *,
-        failed_request_status_codes=_DEFAULT_FAILED_REQUEST_STATUS_CODES,  # type: Set[int]
-    ):
-        # type: (...) -> None
+        failed_request_status_codes: Set[int] = _DEFAULT_FAILED_REQUEST_STATUS_CODES,
+    ) -> None:
 
         if transaction_style not in TRANSACTION_STYLE_VALUES:
             raise ValueError(
@@ -70,16 +70,16 @@ class BottleIntegration(Integration):
         self.failed_request_status_codes = failed_request_status_codes
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         version = parse_version(BOTTLE_VERSION)
         _check_minimum_version(BottleIntegration, version)
 
         old_app = Bottle.__call__
 
         @ensure_integration_enabled(BottleIntegration, old_app)
-        def sentry_patched_wsgi_app(self, environ, start_response):
-            # type: (Any, Dict[str, str], Callable[..., Any]) -> _ScopedResponse
+        def sentry_patched_wsgi_app(
+            self: Any, environ: Dict[str, str], start_response: Callable[..., Any]
+        ) -> _ScopedResponse:
             middleware = SentryWsgiMiddleware(
                 lambda *a, **kw: old_app(self, *a, **kw),
                 span_origin=BottleIntegration.origin,
@@ -92,8 +92,7 @@ class BottleIntegration(Integration):
         old_handle = Bottle._handle
 
         @functools.wraps(old_handle)
-        def _patched_handle(self, environ):
-            # type: (Bottle, Dict[str, Any]) -> Any
+        def _patched_handle(self: Bottle, environ: Dict[str, Any]) -> Any:
             integration = sentry_sdk.get_client().get_integration(BottleIntegration)
             if integration is None:
                 return old_handle(self, environ)
@@ -112,16 +111,14 @@ class BottleIntegration(Integration):
         old_make_callback = Route._make_callback
 
         @functools.wraps(old_make_callback)
-        def patched_make_callback(self, *args, **kwargs):
-            # type: (Route, *object, **object) -> Any
+        def patched_make_callback(self: Route, *args: object, **kwargs: object) -> Any:
             prepared_callback = old_make_callback(self, *args, **kwargs)
 
             integration = sentry_sdk.get_client().get_integration(BottleIntegration)
             if integration is None:
                 return prepared_callback
 
-            def wrapped_callback(*args, **kwargs):
-                # type: (*object, **object) -> Any
+            def wrapped_callback(*args: object, **kwargs: object) -> Any:
                 try:
                     res = prepared_callback(*args, **kwargs)
                 except Exception as exception:
@@ -142,38 +139,33 @@ class BottleIntegration(Integration):
 
 
 class BottleRequestExtractor(RequestExtractor):
-    def env(self):
-        # type: () -> Dict[str, str]
+    def env(self) -> Dict[str, str]:
         return self.request.environ
 
-    def cookies(self):
-        # type: () -> Dict[str, str]
+    def cookies(self) -> Dict[str, str]:
         return self.request.cookies
 
-    def raw_data(self):
-        # type: () -> bytes
+    def raw_data(self) -> bytes:
         return self.request.body.read()
 
-    def form(self):
-        # type: () -> FormsDict
+    def form(self) -> FormsDict:
         if self.is_json():
             return None
         return self.request.forms.decode()
 
-    def files(self):
-        # type: () -> Optional[Dict[str, str]]
+    def files(self) -> Optional[Dict[str, str]]:
         if self.is_json():
             return None
 
         return self.request.files
 
-    def size_of_file(self, file):
-        # type: (FileUpload) -> int
+    def size_of_file(self, file: FileUpload) -> int:
         return file.content_length
 
 
-def _set_transaction_name_and_source(event, transaction_style, request):
-    # type: (Event, str, Any) -> None
+def _set_transaction_name_and_source(
+    event: Event, transaction_style: str, request: Any
+) -> None:
     name = ""
 
     if transaction_style == "url":
@@ -196,11 +188,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(app, request, integration):
-    # type: (Bottle, LocalRequest, BottleIntegration) -> EventProcessor
+def _make_request_event_processor(
+    app: Bottle, request: LocalRequest, integration: BottleIntegration
+) -> 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, request)
 
         with capture_internal_exceptions():
@@ -211,8 +203,7 @@ def _make_request_event_processor(app, request, integration):
     return event_processor
 
 
-def _capture_exception(exception, handled):
-    # type: (BaseException, bool) -> None
+def _capture_exception(exception: BaseException, handled: bool) -> None:
     event, hint = event_from_exception(
         exception,
         client_options=sentry_sdk.get_client().options,

sentry_sdk/integrations/celery/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 from collections.abc import Mapping
 from functools import wraps
@@ -62,11 +63,10 @@ class CeleryIntegration(Integration):
 
     def __init__(
         self,
-        propagate_traces=True,
-        monitor_beat_tasks=False,
-        exclude_beat_tasks=None,
-    ):
-        # type: (bool, bool, Optional[List[str]]) -> None
+        propagate_traces: bool = True,
+        monitor_beat_tasks: bool = False,
+        exclude_beat_tasks: Optional[List[str]] = None,
+    ) -> None:
         self.propagate_traces = propagate_traces
         self.monitor_beat_tasks = monitor_beat_tasks
         self.exclude_beat_tasks = exclude_beat_tasks
@@ -76,8 +76,7 @@ class CeleryIntegration(Integration):
         _setup_celery_beat_signals(monitor_beat_tasks)
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         _check_minimum_version(CeleryIntegration, CELERY_VERSION)
 
         _patch_build_tracer()
@@ -97,16 +96,14 @@ class CeleryIntegration(Integration):
         ignore_logger("celery.redirected")
 
 
-def _set_status(status):
-    # type: (str) -> None
+def _set_status(status: str) -> None:
     with capture_internal_exceptions():
         span = sentry_sdk.get_current_span()
         if span is not None:
             span.set_status(status)
 
 
-def _capture_exception(task, exc_info):
-    # type: (Any, ExcInfo) -> None
+def _capture_exception(task: Any, exc_info: ExcInfo) -> None:
     client = sentry_sdk.get_client()
     if client.get_integration(CeleryIntegration) is None:
         return
@@ -129,10 +126,10 @@ def _capture_exception(task, exc_info):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _make_event_processor(task, uuid, args, kwargs, request=None):
-    # type: (Any, Any, Any, Any, Optional[Any]) -> EventProcessor
-    def event_processor(event, hint):
-        # type: (Event, Hint) -> Optional[Event]
+def _make_event_processor(
+    task: Any, uuid: Any, args: Any, kwargs: Any, request: Optional[Any] = None
+) -> EventProcessor:
+    def event_processor(event: Event, hint: Hint) -> Optional[Event]:
 
         with capture_internal_exceptions():
             tags = event.setdefault("tags", {})
@@ -158,8 +155,9 @@ def _make_event_processor(task, uuid, args, kwargs, request=None):
     return event_processor
 
 
-def _update_celery_task_headers(original_headers, span, monitor_beat_tasks):
-    # type: (dict[str, Any], Optional[Span], bool) -> dict[str, Any]
+def _update_celery_task_headers(
+    original_headers: dict[str, Any], span: Optional[Span], monitor_beat_tasks: bool
+) -> dict[str, Any]:
     """
     Updates the headers of the Celery task with the tracing information
     and eventually Sentry Crons monitoring information for beat tasks.
@@ -233,20 +231,16 @@ def _update_celery_task_headers(original_headers, span, monitor_beat_tasks):
 
 
 class NoOpMgr:
-    def __enter__(self):
-        # type: () -> None
+    def __enter__(self) -> None:
         return None
 
-    def __exit__(self, exc_type, exc_value, traceback):
-        # type: (Any, Any, Any) -> None
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         return None
 
 
-def _wrap_task_run(f):
-    # type: (F) -> F
+def _wrap_task_run(f: F) -> F:
     @wraps(f)
-    def apply_async(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def apply_async(*args: Any, **kwargs: Any) -> Any:
         # Note: kwargs can contain headers=None, so no setdefault!
         # Unsure which backend though.
         integration = sentry_sdk.get_client().get_integration(CeleryIntegration)
@@ -262,7 +256,7 @@ def _wrap_task_run(f):
             return f(*args, **kwargs)
 
         if isinstance(args[0], Task):
-            task_name = args[0].name  # type: str
+            task_name: str = args[0].name
         elif len(args) > 1 and isinstance(args[1], str):
             task_name = args[1]
         else:
@@ -270,7 +264,7 @@ def _wrap_task_run(f):
 
         task_started_from_beat = sentry_sdk.get_isolation_scope()._name == "celery-beat"
 
-        span_mgr = (
+        span_mgr: Union[Span, NoOpMgr] = (
             sentry_sdk.start_span(
                 op=OP.QUEUE_SUBMIT_CELERY,
                 name=task_name,
@@ -279,7 +273,7 @@ def _wrap_task_run(f):
             )
             if not task_started_from_beat
             else NoOpMgr()
-        )  # type: Union[Span, NoOpMgr]
+        )
 
         with span_mgr as span:
             kwargs["headers"] = _update_celery_task_headers(
@@ -290,8 +284,7 @@ def _wrap_task_run(f):
     return apply_async  # type: ignore
 
 
-def _wrap_tracer(task, f):
-    # type: (Any, F) -> F
+def _wrap_tracer(task: Any, f: F) -> F:
 
     # Need to wrap tracer for pushing the scope before prerun is sent, and
     # popping it after postrun is sent.
@@ -301,8 +294,7 @@ def _wrap_tracer(task, f):
     # crashes.
     @wraps(f)
     @ensure_integration_enabled(CeleryIntegration, f)
-    def _inner(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def _inner(*args: Any, **kwargs: Any) -> Any:
         with isolation_scope() as scope:
             scope._name = "celery"
             scope.clear_breadcrumbs()
@@ -333,8 +325,7 @@ def _wrap_tracer(task, f):
     return _inner  # type: ignore
 
 
-def _set_messaging_destination_name(task, span):
-    # type: (Any, Span) -> None
+def _set_messaging_destination_name(task: Any, span: Span) -> None:
     """Set "messaging.destination.name" tag for span"""
     with capture_internal_exceptions():
         delivery_info = task.request.delivery_info
@@ -346,8 +337,7 @@ def _set_messaging_destination_name(task, span):
                 span.set_attribute(SPANDATA.MESSAGING_DESTINATION_NAME, routing_key)
 
 
-def _wrap_task_call(task, f):
-    # type: (Any, F) -> F
+def _wrap_task_call(task: Any, f: F) -> F:
 
     # Need to wrap task call because the exception is caught before we get to
     # see it. Also celery's reported stacktrace is untrustworthy.
@@ -358,8 +348,7 @@ def _wrap_task_call(task, f):
     # to add @functools.wraps(f) here.
     # https://github.com/getsentry/sentry-python/issues/421
     @ensure_integration_enabled(CeleryIntegration, f)
-    def _inner(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def _inner(*args: Any, **kwargs: Any) -> Any:
         try:
             with sentry_sdk.start_span(
                 op=OP.QUEUE_PROCESS,
@@ -409,14 +398,12 @@ def _wrap_task_call(task, f):
     return _inner  # type: ignore
 
 
-def _patch_build_tracer():
-    # type: () -> None
+def _patch_build_tracer() -> None:
     import celery.app.trace as trace  # type: ignore
 
     original_build_tracer = trace.build_tracer
 
-    def sentry_build_tracer(name, task, *args, **kwargs):
-        # type: (Any, Any, *Any, **Any) -> Any
+    def sentry_build_tracer(name: Any, task: Any, *args: Any, **kwargs: Any) -> Any:
         if not getattr(task, "_sentry_is_patched", False):
             # determine whether Celery will use __call__ or run and patch
             # accordingly
@@ -435,20 +422,17 @@ def _patch_build_tracer():
     trace.build_tracer = sentry_build_tracer
 
 
-def _patch_task_apply_async():
-    # type: () -> None
+def _patch_task_apply_async() -> None:
     Task.apply_async = _wrap_task_run(Task.apply_async)
 
 
-def _patch_celery_send_task():
-    # type: () -> None
+def _patch_celery_send_task() -> None:
     from celery import Celery
 
     Celery.send_task = _wrap_task_run(Celery.send_task)
 
 
-def _patch_worker_exit():
-    # type: () -> None
+def _patch_worker_exit() -> None:
 
     # Need to flush queue before worker shutdown because a crashing worker will
     # call os._exit
@@ -456,8 +440,7 @@ def _patch_worker_exit():
 
     original_workloop = Worker.workloop
 
-    def sentry_workloop(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def sentry_workloop(*args: Any, **kwargs: Any) -> Any:
         try:
             return original_workloop(*args, **kwargs)
         finally:
@@ -471,13 +454,11 @@ def _patch_worker_exit():
     Worker.workloop = sentry_workloop
 
 
-def _patch_producer_publish():
-    # type: () -> None
+def _patch_producer_publish() -> None:
     original_publish = Producer.publish
 
     @ensure_integration_enabled(CeleryIntegration, original_publish)
-    def sentry_publish(self, *args, **kwargs):
-        # type: (Producer, *Any, **Any) -> Any
+    def sentry_publish(self: Producer, *args: Any, **kwargs: Any) -> Any:
         kwargs_headers = kwargs.get("headers", {})
         if not isinstance(kwargs_headers, Mapping):
             # Ensure kwargs_headers is a Mapping, so we can safely call get().
@@ -521,8 +502,7 @@ def _patch_producer_publish():
     Producer.publish = sentry_publish
 
 
-def _prepopulate_attributes(task, args, kwargs):
-    # type: (Any, *Any, **Any) -> dict[str, str]
+def _prepopulate_attributes(task: Any, args: Any, kwargs: Any) -> dict[str, str]:
     attributes = {
         "celery.job.task": task.name,
     }

sentry_sdk/integrations/celery/beat.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.crons import capture_checkin, MonitorStatus
 from sentry_sdk.integrations import DidNotEnable
@@ -42,8 +43,7 @@ except ImportError:
     RedBeatScheduler = None
 
 
-def _get_headers(task):
-    # type: (Task) -> dict[str, Any]
+def _get_headers(task: Task) -> dict[str, Any]:
     headers = task.request.get("headers") or {}
 
     # flatten nested headers
@@ -56,12 +56,13 @@ def _get_headers(task):
     return headers
 
 
-def _get_monitor_config(celery_schedule, app, monitor_name):
-    # type: (Any, Celery, str) -> MonitorConfig
-    monitor_config = {}  # type: MonitorConfig
-    schedule_type = None  # type: Optional[MonitorConfigScheduleType]
-    schedule_value = None  # type: Optional[Union[str, int]]
-    schedule_unit = None  # type: Optional[MonitorConfigScheduleUnit]
+def _get_monitor_config(
+    celery_schedule: Any, app: Celery, monitor_name: str
+) -> MonitorConfig:
+    monitor_config: MonitorConfig = {}
+    schedule_type: Optional[MonitorConfigScheduleType] = None
+    schedule_value: Optional[Union[str, int]] = None
+    schedule_unit: Optional[MonitorConfigScheduleUnit] = None
 
     if isinstance(celery_schedule, crontab):
         schedule_type = "crontab"
@@ -113,8 +114,11 @@ def _get_monitor_config(celery_schedule, app, monitor_name):
     return monitor_config
 
 
-def _apply_crons_data_to_schedule_entry(scheduler, schedule_entry, integration):
-    # type: (Any, Any, sentry_sdk.integrations.celery.CeleryIntegration) -> None
+def _apply_crons_data_to_schedule_entry(
+    scheduler: Any,
+    schedule_entry: Any,
+    integration: sentry_sdk.integrations.celery.CeleryIntegration,
+) -> None:
     """
     Add Sentry Crons information to the schedule_entry headers.
     """
@@ -158,8 +162,7 @@ def _apply_crons_data_to_schedule_entry(scheduler, schedule_entry, integration):
     schedule_entry.options["headers"] = headers
 
 
-def _wrap_beat_scheduler(original_function):
-    # type: (Callable[..., Any]) -> Callable[..., Any]
+def _wrap_beat_scheduler(original_function: Callable[..., Any]) -> Callable[..., Any]:
     """
     Makes sure that:
     - a new Sentry trace is started for each task started by Celery Beat and
@@ -178,8 +181,7 @@ def _wrap_beat_scheduler(original_function):
 
     from sentry_sdk.integrations.celery import CeleryIntegration
 
-    def sentry_patched_scheduler(*args, **kwargs):
-        # type: (*Any, **Any) -> None
+    def sentry_patched_scheduler(*args: Any, **kwargs: Any) -> None:
         integration = sentry_sdk.get_client().get_integration(CeleryIntegration)
         if integration is None:
             return original_function(*args, **kwargs)
@@ -197,29 +199,25 @@ def _wrap_beat_scheduler(original_function):
     return sentry_patched_scheduler
 
 
-def _patch_beat_apply_entry():
-    # type: () -> None
+def _patch_beat_apply_entry() -> None:
     Scheduler.apply_entry = _wrap_beat_scheduler(Scheduler.apply_entry)
 
 
-def _patch_redbeat_apply_async():
-    # type: () -> None
+def _patch_redbeat_apply_async() -> None:
     if RedBeatScheduler is None:
         return
 
     RedBeatScheduler.apply_async = _wrap_beat_scheduler(RedBeatScheduler.apply_async)
 
 
-def _setup_celery_beat_signals(monitor_beat_tasks):
-    # type: (bool) -> None
+def _setup_celery_beat_signals(monitor_beat_tasks: bool) -> None:
     if monitor_beat_tasks:
         task_success.connect(crons_task_success)
         task_failure.connect(crons_task_failure)
         task_retry.connect(crons_task_retry)
 
 
-def crons_task_success(sender, **kwargs):
-    # type: (Task, dict[Any, Any]) -> None
+def crons_task_success(sender: Task, **kwargs: dict[Any, Any]) -> None:
     logger.debug("celery_task_success %s", sender)
     headers = _get_headers(sender)
 
@@ -243,8 +241,7 @@ def crons_task_success(sender, **kwargs):
     )
 
 
-def crons_task_failure(sender, **kwargs):
-    # type: (Task, dict[Any, Any]) -> None
+def crons_task_failure(sender: Task, **kwargs: dict[Any, Any]) -> None:
     logger.debug("celery_task_failure %s", sender)
     headers = _get_headers(sender)
 
@@ -268,8 +265,7 @@ def crons_task_failure(sender, **kwargs):
     )
 
 
-def crons_task_retry(sender, **kwargs):
-    # type: (Task, dict[Any, Any]) -> None
+def crons_task_retry(sender: Task, **kwargs: dict[Any, Any]) -> None:
     logger.debug("celery_task_retry %s", sender)
     headers = _get_headers(sender)