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

sentry_sdk/integrations/redis/modules/caches.py

@@ -2,6 +2,7 @@
 Code used for the Caches module in Sentry
 """
 
+from __future__ import annotations
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations.redis.utils import _get_safe_key, _key_as_string
 from sentry_sdk.utils import capture_internal_exceptions
@@ -16,8 +17,7 @@ if TYPE_CHECKING:
     from typing import Any, Optional
 
 
-def _get_op(name):
-    # type: (str) -> Optional[str]
+def _get_op(name: str) -> Optional[str]:
     op = None
     if name.lower() in GET_COMMANDS:
         op = OP.CACHE_GET
@@ -27,8 +27,12 @@ def _get_op(name):
     return op
 
 
-def _compile_cache_span_properties(redis_command, args, kwargs, integration):
-    # type: (str, tuple[Any, ...], dict[str, Any], RedisIntegration) -> dict[str, Any]
+def _compile_cache_span_properties(
+    redis_command: str,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+    integration: RedisIntegration,
+) -> dict[str, Any]:
     key = _get_safe_key(redis_command, args, kwargs)
     key_as_string = _key_as_string(key)
     keys_as_string = key_as_string.split(", ")
@@ -61,8 +65,12 @@ def _compile_cache_span_properties(redis_command, args, kwargs, integration):
     return properties
 
 
-def _get_cache_span_description(redis_command, args, kwargs, integration):
-    # type: (str, tuple[Any, ...], dict[str, Any], RedisIntegration) -> str
+def _get_cache_span_description(
+    redis_command: str,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+    integration: RedisIntegration,
+) -> str:
     description = _key_as_string(_get_safe_key(redis_command, args, kwargs))
 
     data_should_be_truncated = (
@@ -74,8 +82,9 @@ def _get_cache_span_description(redis_command, args, kwargs, integration):
     return description
 
 
-def _get_cache_data(redis_client, properties, return_value):
-    # type: (Any, dict[str, Any], Optional[Any]) -> dict[str, Any]
+def _get_cache_data(
+    redis_client: Any, properties: dict[str, Any], return_value: Optional[Any]
+) -> dict[str, Any]:
     data = {}
 
     with capture_internal_exceptions():

sentry_sdk/integrations/redis/modules/queries.py

@@ -2,6 +2,7 @@
 Code used for the Queries module in Sentry
 """
 
+from __future__ import annotations
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations.redis.utils import _get_safe_command
 from sentry_sdk.utils import capture_internal_exceptions
@@ -14,8 +15,9 @@ if TYPE_CHECKING:
     from typing import Any
 
 
-def _compile_db_span_properties(integration, redis_command, args):
-    # type: (RedisIntegration, str, tuple[Any, ...]) -> dict[str, Any]
+def _compile_db_span_properties(
+    integration: RedisIntegration, redis_command: str, args: tuple[Any, ...]
+) -> dict[str, Any]:
     description = _get_db_span_description(integration, redis_command, args)
 
     properties = {
@@ -26,8 +28,9 @@ def _compile_db_span_properties(integration, redis_command, args):
     return properties
 
 
-def _get_db_span_description(integration, command_name, args):
-    # type: (RedisIntegration, str, tuple[Any, ...]) -> str
+def _get_db_span_description(
+    integration: RedisIntegration, command_name: str, args: tuple[Any, ...]
+) -> str:
     description = command_name
 
     with capture_internal_exceptions():
@@ -42,8 +45,7 @@ def _get_db_span_description(integration, command_name, args):
     return description
 
 
-def _get_connection_data(connection_params):
-    # type: (dict[str, Any]) -> dict[str, Any]
+def _get_connection_data(connection_params: dict[str, Any]) -> dict[str, Any]:
     data = {
         SPANDATA.DB_SYSTEM: "redis",
     }
@@ -63,8 +65,7 @@ def _get_connection_data(connection_params):
     return data
 
 
-def _get_db_data(redis_instance):
-    # type: (Redis[Any]) -> dict[str, Any]
+def _get_db_data(redis_instance: Redis[Any]) -> dict[str, Any]:
     try:
         return _get_connection_data(redis_instance.connection_pool.connection_kwargs)
     except AttributeError:

sentry_sdk/integrations/redis/rb.py

@@ -4,12 +4,13 @@ Instrumentation for Redis Blaster (rb)
 https://github.com/getsentry/rb
 """
 
+from __future__ import annotations
+
 from sentry_sdk.integrations.redis._sync_common import patch_redis_client
 from sentry_sdk.integrations.redis.modules.queries import _get_db_data
 
 
-def _patch_rb():
-    # type: () -> None
+def _patch_rb() -> None:
     try:
         import rb.clients  # type: ignore
     except ImportError:

sentry_sdk/integrations/redis/redis.py

@@ -4,6 +4,8 @@ Instrumentation for Redis
 https://github.com/redis/redis-py
 """
 
+from __future__ import annotations
+
 from sentry_sdk.integrations.redis._sync_common import (
     patch_redis_client,
     patch_redis_pipeline,
@@ -16,13 +18,11 @@ if TYPE_CHECKING:
     from typing import Any, Sequence
 
 
-def _get_redis_command_args(command):
-    # type: (Any) -> Sequence[Any]
+def _get_redis_command_args(command: Any) -> Sequence[Any]:
     return command[0]
 
 
-def _patch_redis(StrictRedis, client):  # noqa: N803
-    # type: (Any, Any) -> None
+def _patch_redis(StrictRedis: Any, client: Any) -> None:  # noqa: N803
     patch_redis_client(
         StrictRedis,
         is_cluster=False,

sentry_sdk/integrations/redis/redis_cluster.py

@@ -5,6 +5,8 @@ This is part of the main redis-py client.
 https://github.com/redis/redis-py/blob/master/redis/cluster.py
 """
 
+from __future__ import annotations
+
 from sentry_sdk.integrations.redis._sync_common import (
     patch_redis_client,
     patch_redis_pipeline,
@@ -25,8 +27,9 @@ if TYPE_CHECKING:
     )
 
 
-def _get_async_cluster_db_data(async_redis_cluster_instance):
-    # type: (AsyncRedisCluster[Any]) -> dict[str, Any]
+def _get_async_cluster_db_data(
+    async_redis_cluster_instance: AsyncRedisCluster[Any],
+) -> dict[str, Any]:
     default_node = async_redis_cluster_instance.get_default_node()
     if default_node is not None and default_node.connection_kwargs is not None:
         return _get_connection_data(default_node.connection_kwargs)
@@ -34,18 +37,24 @@ def _get_async_cluster_db_data(async_redis_cluster_instance):
         return {}
 
 
-def _get_async_cluster_pipeline_db_data(async_redis_cluster_pipeline_instance):
-    # type: (AsyncClusterPipeline[Any]) -> dict[str, Any]
+def _get_async_cluster_pipeline_db_data(
+    async_redis_cluster_pipeline_instance: AsyncClusterPipeline[Any],
+) -> dict[str, Any]:
     with capture_internal_exceptions():
-        return _get_async_cluster_db_data(
-            # the AsyncClusterPipeline has always had a `_client` attr but it is private so potentially problematic and mypy
-            # does not recognize it - see https://github.com/redis/redis-py/blame/v5.0.0/redis/asyncio/cluster.py#L1386
-            async_redis_cluster_pipeline_instance._client,  # type: ignore[attr-defined]
-        )
+        client = getattr(async_redis_cluster_pipeline_instance, "cluster_client", None)
+        if client is None:
+            # In older redis-py versions, the AsyncClusterPipeline had a `_client`
+            # attr but it is private so potentially problematic and mypy does not
+            # recognize it - see
+            # https://github.com/redis/redis-py/blame/v5.0.0/redis/asyncio/cluster.py#L1386
+            client = (
+                async_redis_cluster_pipeline_instance._client  # type: ignore[attr-defined]
+            )
+
+        return _get_async_cluster_db_data(client)
 
 
-def _get_cluster_db_data(redis_cluster_instance):
-    # type: (RedisCluster[Any]) -> dict[str, Any]
+def _get_cluster_db_data(redis_cluster_instance: RedisCluster[Any]) -> dict[str, Any]:
     default_node = redis_cluster_instance.get_default_node()
 
     if default_node is not None:
@@ -58,8 +67,7 @@ def _get_cluster_db_data(redis_cluster_instance):
         return {}
 
 
-def _patch_redis_cluster():
-    # type: () -> None
+def _patch_redis_cluster() -> None:
     """Patches the cluster module on redis SDK (as opposed to rediscluster library)"""
     try:
         from redis import RedisCluster, cluster

sentry_sdk/integrations/redis/redis_py_cluster_legacy.py

@@ -5,6 +5,8 @@ The project redis-py-cluster is EOL and was integrated into redis-py starting fr
 https://github.com/grokzen/redis-py-cluster
 """
 
+from __future__ import annotations
+
 from sentry_sdk.integrations.redis._sync_common import (
     patch_redis_client,
     patch_redis_pipeline,
@@ -13,8 +15,7 @@ from sentry_sdk.integrations.redis.modules.queries import _get_db_data
 from sentry_sdk.integrations.redis.utils import _parse_rediscluster_command
 
 
-def _patch_rediscluster():
-    # type: () -> None
+def _patch_rediscluster() -> None:
     try:
         import rediscluster  # type: ignore
     except ImportError:

sentry_sdk/integrations/redis/utils.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations.redis.consts import (
@@ -26,8 +27,7 @@ TAG_KEYS = [
 ]
 
 
-def _update_span(span, *data_bags):
-    # type: (Span, *dict[str, Any]) -> None
+def _update_span(span: Span, *data_bags: dict[str, Any]) -> None:
     """
     Set tags and data on the given span to data from the given data bags.
     """
@@ -39,8 +39,7 @@ def _update_span(span, *data_bags):
                 span.set_attribute(key, value)
 
 
-def _create_breadcrumb(message, *data_bags):
-    # type: (str, *dict[str, Any]) -> None
+def _create_breadcrumb(message: str, *data_bags: dict[str, Any]) -> None:
     """
     Create a breadcrumb containing the tags data from the given data bags.
     """
@@ -58,8 +57,7 @@ def _create_breadcrumb(message, *data_bags):
     )
 
 
-def _get_safe_command(name, args):
-    # type: (str, Sequence[Any]) -> str
+def _get_safe_command(name: str, args: Sequence[Any]) -> str:
     command_parts = [name]
 
     for i, arg in enumerate(args):
@@ -86,8 +84,7 @@ def _get_safe_command(name, args):
     return command
 
 
-def _safe_decode(key):
-    # type: (Any) -> str
+def _safe_decode(key: Any) -> str:
     if isinstance(key, bytes):
         try:
             return key.decode()
@@ -97,8 +94,7 @@ def _safe_decode(key):
     return str(key)
 
 
-def _key_as_string(key):
-    # type: (Any) -> str
+def _key_as_string(key: Any) -> str:
     if isinstance(key, (dict, list, tuple)):
         key = ", ".join(_safe_decode(x) for x in key)
     elif isinstance(key, bytes):
@@ -111,8 +107,9 @@ def _key_as_string(key):
     return key
 
 
-def _get_safe_key(method_name, args, kwargs):
-    # type: (str, Optional[tuple[Any, ...]], Optional[dict[str, Any]]) -> Optional[tuple[str, ...]]
+def _get_safe_key(
+    method_name: str, args: Optional[tuple[Any, ...]], kwargs: Optional[dict[str, Any]]
+) -> Optional[tuple[str, ...]]:
     """
     Gets the key (or keys) from the given method_name.
     The method_name could be a redis command or a django caching command
@@ -142,37 +139,39 @@ def _get_safe_key(method_name, args, kwargs):
     return key
 
 
-def _parse_rediscluster_command(command):
-    # type: (Any) -> Sequence[Any]
+def _parse_rediscluster_command(command: Any) -> Sequence[Any]:
     return command.args
 
 
-def _get_pipeline_data(is_cluster, get_command_args_fn, is_transaction, command_stack):
-    # type: (bool, Any, bool, Sequence[Any]) -> dict[str, Any]
-    data = {
+def _get_pipeline_data(
+    is_cluster: bool,
+    get_command_args_fn: Any,
+    is_transaction: bool,
+    command_seq: Sequence[Any],
+) -> dict[str, Any]:
+    data: dict[str, Any] = {
         "redis.is_cluster": is_cluster,
         "redis.transaction": is_transaction,
-    }  # type: dict[str, Any]
+    }
 
     commands = []
-    for i, arg in enumerate(command_stack):
+    for i, arg in enumerate(command_seq):
         if i >= _MAX_NUM_COMMANDS:
             break
 
         command = get_command_args_fn(arg)
         commands.append(_get_safe_command(command[0], command[1:]))
 
-    data["redis.commands.count"] = len(command_stack)
+    data["redis.commands.count"] = len(command_seq)
     data["redis.commands.first_ten"] = commands
 
     return data
 
 
-def _get_client_data(is_cluster, name, *args):
-    # type: (bool, str, *Any) -> dict[str, Any]
-    data = {
+def _get_client_data(is_cluster: bool, name: str, *args: Any) -> dict[str, Any]:
+    data: dict[str, Any] = {
         "redis.is_cluster": is_cluster,
-    }  # type: dict[str, Any]
+    }
 
     if name:
         data["redis.command"] = name

sentry_sdk/integrations/rq.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import weakref
 
 import sentry_sdk
@@ -49,16 +50,16 @@ class RqIntegration(Integration):
     origin = f"auto.queue.{identifier}"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         version = parse_version(RQ_VERSION)
         _check_minimum_version(RqIntegration, version)
 
         old_perform_job = Worker.perform_job
 
         @ensure_integration_enabled(RqIntegration, old_perform_job)
-        def sentry_patched_perform_job(self, job, queue, *args, **kwargs):
-            # type: (Any, Job, Queue, *Any, **Any) -> bool
+        def sentry_patched_perform_job(
+            self: Any, job: Job, queue: Queue, *args: Any, **kwargs: Any
+        ) -> bool:
             with sentry_sdk.new_scope() as scope:
                 try:
                     transaction_name = job.func_name or DEFAULT_TRANSACTION_NAME
@@ -95,8 +96,9 @@ class RqIntegration(Integration):
 
         old_handle_exception = Worker.handle_exception
 
-        def sentry_patched_handle_exception(self, job, *exc_info, **kwargs):
-            # type: (Worker, Any, *Any, **Any) -> Any
+        def sentry_patched_handle_exception(
+            self: Worker, job: Any, *exc_info: Any, **kwargs: Any
+        ) -> Any:
             retry = (
                 hasattr(job, "retries_left")
                 and job.retries_left
@@ -113,8 +115,7 @@ class RqIntegration(Integration):
         old_enqueue_job = Queue.enqueue_job
 
         @ensure_integration_enabled(RqIntegration, old_enqueue_job)
-        def sentry_patched_enqueue_job(self, job, **kwargs):
-            # type: (Queue, Any, **Any) -> Any
+        def sentry_patched_enqueue_job(self: Queue, job: Any, **kwargs: Any) -> Any:
             job.meta["_sentry_trace_headers"] = dict(
                 sentry_sdk.get_current_scope().iter_trace_propagation_headers()
             )
@@ -126,10 +127,8 @@ class RqIntegration(Integration):
         ignore_logger("rq.worker")
 
 
-def _make_event_processor(weak_job):
-    # type: (Callable[[], Job]) -> EventProcessor
-    def event_processor(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+def _make_event_processor(weak_job: Callable[[], Job]) -> EventProcessor:
+    def event_processor(event: Event, hint: dict[str, Any]) -> Event:
         job = weak_job()
         if job is not None:
             with capture_internal_exceptions():
@@ -159,8 +158,7 @@ def _make_event_processor(weak_job):
     return event_processor
 
 
-def _capture_exception(exc_info, **kwargs):
-    # type: (ExcInfo, **Any) -> None
+def _capture_exception(exc_info: ExcInfo, **kwargs: Any) -> None:
     client = sentry_sdk.get_client()
 
     event, hint = event_from_exception(
@@ -172,8 +170,7 @@ def _capture_exception(exc_info, **kwargs):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _prepopulate_attributes(job, queue):
-    # type: (Job, Queue) -> dict[str, Any]
+def _prepopulate_attributes(job: Job, queue: Queue) -> dict[str, Any]:
     attributes = {
         "messaging.system": "rq",
         "rq.job.id": job.id,

sentry_sdk/integrations/rust_tracing.py

@@ -30,9 +30,13 @@ sentry_sdk.init(
 Each native extension requires its own integration.
 """
 
+from __future__ import annotations
 import json
 from enum import Enum, auto
-from typing import Any, Callable, Dict, Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Callable, Dict, Optional
 
 import sentry_sdk
 from sentry_sdk.integrations import Integration
@@ -56,8 +60,7 @@ class EventTypeMapping(Enum):
     Event = auto()
 
 
-def tracing_level_to_sentry_level(level):
-    # type: (str) -> sentry_sdk._types.LogLevelStr
+def tracing_level_to_sentry_level(level: str) -> sentry_sdk._types.LogLevelStr:
     level = RustTracingLevel(level)
     if level in (RustTracingLevel.Trace, RustTracingLevel.Debug):
         return "debug"
@@ -97,15 +100,15 @@ def process_event(event: Dict[str, Any]) -> None:
 
     logger = metadata.get("target")
     level = tracing_level_to_sentry_level(metadata.get("level"))
-    message = event.get("message")  # type: sentry_sdk._types.Any
+    message: sentry_sdk._types.Any = event.get("message")
     contexts = extract_contexts(event)
 
-    sentry_event = {
+    sentry_event: sentry_sdk._types.Event = {
         "logger": logger,
         "level": level,
         "message": message,
         "contexts": contexts,
-    }  # type: sentry_sdk._types.Event
+    }
 
     sentry_sdk.capture_event(sentry_event)
 

sentry_sdk/integrations/sanic.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 import weakref
 from inspect import isawaitable
@@ -59,8 +60,9 @@ class SanicIntegration(Integration):
     origin = f"auto.http.{identifier}"
     version = None
 
-    def __init__(self, unsampled_statuses=frozenset({404})):
-        # type: (Optional[Container[int]]) -> None
+    def __init__(
+        self, unsampled_statuses: Optional[Container[int]] = frozenset({404})
+    ) -> None:
         """
         The unsampled_statuses parameter can be used to specify for which HTTP statuses the
         transactions should not be sent to Sentry. By default, transactions are sent for all
@@ -70,8 +72,7 @@ class SanicIntegration(Integration):
         self._unsampled_statuses = unsampled_statuses or set()
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         SanicIntegration.version = parse_version(SANIC_VERSION)
         _check_minimum_version(SanicIntegration, SanicIntegration.version)
 
@@ -103,56 +104,45 @@ class SanicIntegration(Integration):
 
 
 class SanicRequestExtractor(RequestExtractor):
-    def content_length(self):
-        # type: () -> int
+    def content_length(self) -> int:
         if self.request.body is None:
             return 0
         return len(self.request.body)
 
-    def cookies(self):
-        # type: () -> Dict[str, str]
+    def cookies(self) -> Dict[str, str]:
         return dict(self.request.cookies)
 
-    def raw_data(self):
-        # type: () -> bytes
+    def raw_data(self) -> bytes:
         return self.request.body
 
-    def form(self):
-        # type: () -> RequestParameters
+    def form(self) -> RequestParameters:
         return self.request.form
 
-    def is_json(self):
-        # type: () -> bool
+    def is_json(self) -> bool:
         raise NotImplementedError()
 
-    def json(self):
-        # type: () -> Optional[Any]
+    def json(self) -> Optional[Any]:
         return self.request.json
 
-    def files(self):
-        # type: () -> RequestParameters
+    def files(self) -> RequestParameters:
         return self.request.files
 
-    def size_of_file(self, file):
-        # type: (Any) -> int
+    def size_of_file(self, file: Any) -> int:
         return len(file.body or ())
 
 
-def _setup_sanic():
-    # type: () -> None
+def _setup_sanic() -> None:
     Sanic._startup = _startup
     ErrorHandler.lookup = _sentry_error_handler_lookup
 
 
-def _setup_legacy_sanic():
-    # type: () -> None
+def _setup_legacy_sanic() -> None:
     Sanic.handle_request = _legacy_handle_request
     Router.get = _legacy_router_get
     ErrorHandler.lookup = _sentry_error_handler_lookup
 
 
-async def _startup(self):
-    # type: (Sanic) -> None
+async def _startup(self: Sanic) -> None:
     # This happens about as early in the lifecycle as possible, just after the
     # Request object is created. The body has not yet been consumed.
     self.signal("http.lifecycle.request")(_context_enter)
@@ -171,8 +161,7 @@ async def _startup(self):
     await old_startup(self)
 
 
-async def _context_enter(request):
-    # type: (Request) -> None
+async def _context_enter(request: Request) -> None:
     request.ctx._sentry_do_integration = (
         sentry_sdk.get_client().get_integration(SanicIntegration) is not None
     )
@@ -203,8 +192,9 @@ async def _context_enter(request):
     ).__enter__()
 
 
-async def _context_exit(request, response=None):
-    # type: (Request, Optional[BaseHTTPResponse]) -> None
+async def _context_exit(
+    request: Request, response: Optional[BaseHTTPResponse] = None
+) -> None:
     with capture_internal_exceptions():
         if not request.ctx._sentry_do_integration:
             return
@@ -233,8 +223,7 @@ async def _context_exit(request, response=None):
         request.ctx._sentry_scope_manager.__exit__(None, None, None)
 
 
-async def _set_transaction(request, route, **_):
-    # type: (Request, Route, **Any) -> None
+async def _set_transaction(request: Request, route: Route, **_: Any) -> None:
     if request.ctx._sentry_do_integration:
         with capture_internal_exceptions():
             scope = sentry_sdk.get_current_scope()
@@ -242,8 +231,9 @@ async def _set_transaction(request, route, **_):
             scope.set_transaction_name(route_name, source=TransactionSource.COMPONENT)
 
 
-def _sentry_error_handler_lookup(self, exception, *args, **kwargs):
-    # type: (Any, Exception, *Any, **Any) -> Optional[object]
+def _sentry_error_handler_lookup(
+    self: Any, exception: Exception, *args: Any, **kwargs: Any
+) -> Optional[object]:
     _capture_exception(exception)
     old_error_handler = old_error_handler_lookup(self, exception, *args, **kwargs)
 
@@ -253,8 +243,9 @@ def _sentry_error_handler_lookup(self, exception, *args, **kwargs):
     if sentry_sdk.get_client().get_integration(SanicIntegration) is None:
         return old_error_handler
 
-    async def sentry_wrapped_error_handler(request, exception):
-        # type: (Request, Exception) -> Any
+    async def sentry_wrapped_error_handler(
+        request: Request, exception: Exception
+    ) -> Any:
         try:
             response = old_error_handler(request, exception)
             if isawaitable(response):
@@ -276,8 +267,9 @@ def _sentry_error_handler_lookup(self, exception, *args, **kwargs):
     return sentry_wrapped_error_handler
 
 
-async def _legacy_handle_request(self, request, *args, **kwargs):
-    # type: (Any, Request, *Any, **Any) -> Any
+async def _legacy_handle_request(
+    self: Any, request: Request, *args: Any, **kwargs: Any
+) -> Any:
     if sentry_sdk.get_client().get_integration(SanicIntegration) is None:
         return await old_handle_request(self, request, *args, **kwargs)
 
@@ -294,8 +286,7 @@ async def _legacy_handle_request(self, request, *args, **kwargs):
         return response
 
 
-def _legacy_router_get(self, *args):
-    # type: (Any, Union[Any, Request]) -> Any
+def _legacy_router_get(self: Any, *args: Union[Any, Request]) -> Any:
     rv = old_router_get(self, *args)
     if sentry_sdk.get_client().get_integration(SanicIntegration) is not None:
         with capture_internal_exceptions():
@@ -325,8 +316,7 @@ def _legacy_router_get(self, *args):
 
 
 @ensure_integration_enabled(SanicIntegration)
-def _capture_exception(exception):
-    # type: (Union[ExcInfo, BaseException]) -> None
+def _capture_exception(exception: Union[ExcInfo, BaseException]) -> None:
     with capture_internal_exceptions():
         event, hint = event_from_exception(
             exception,
@@ -340,10 +330,8 @@ def _capture_exception(exception):
         sentry_sdk.capture_event(event, hint=hint)
 
 
-def _make_request_processor(weak_request):
-    # type: (Callable[[], Request]) -> EventProcessor
-    def sanic_processor(event, hint):
-        # type: (Event, Optional[Hint]) -> Optional[Event]
+def _make_request_processor(weak_request: Callable[[], Request]) -> EventProcessor:
+    def sanic_processor(event: Event, hint: Optional[Hint]) -> Optional[Event]:
 
         try:
             if hint and issubclass(hint["exc_info"][0], SanicException):