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

sentry_sdk/integrations/pyramid.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 import os
 import sys
@@ -40,8 +41,7 @@ if TYPE_CHECKING:
 
 if getattr(Request, "authenticated_userid", None):
 
-    def authenticated_userid(request):
-        # type: (Request) -> Optional[Any]
+    def authenticated_userid(request: Request) -> Optional[Any]:
         return request.authenticated_userid
 
 else:
@@ -58,8 +58,7 @@ class PyramidIntegration(Integration):
 
     transaction_style = ""
 
-    def __init__(self, transaction_style="route_name"):
-        # type: (str) -> None
+    def __init__(self, transaction_style: str = "route_name") -> None:
         if transaction_style not in TRANSACTION_STYLE_VALUES:
             raise ValueError(
                 "Invalid value for transaction_style: %s (must be in %s)"
@@ -68,15 +67,15 @@ class PyramidIntegration(Integration):
         self.transaction_style = transaction_style
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         from pyramid import router
 
         old_call_view = router._call_view
 
         @functools.wraps(old_call_view)
-        def sentry_patched_call_view(registry, request, *args, **kwargs):
-            # type: (Any, Request, *Any, **Any) -> Response
+        def sentry_patched_call_view(
+            registry: Any, request: Request, *args: Any, **kwargs: Any
+        ) -> Response:
             integration = sentry_sdk.get_client().get_integration(PyramidIntegration)
             if integration is None:
                 return old_call_view(registry, request, *args, **kwargs)
@@ -96,8 +95,9 @@ class PyramidIntegration(Integration):
         if hasattr(Request, "invoke_exception_view"):
             old_invoke_exception_view = Request.invoke_exception_view
 
-            def sentry_patched_invoke_exception_view(self, *args, **kwargs):
-                # type: (Request, *Any, **Any) -> Any
+            def sentry_patched_invoke_exception_view(
+                self: Request, *args: Any, **kwargs: Any
+            ) -> Any:
                 rv = old_invoke_exception_view(self, *args, **kwargs)
 
                 if (
@@ -116,10 +116,12 @@ class PyramidIntegration(Integration):
         old_wsgi_call = router.Router.__call__
 
         @ensure_integration_enabled(PyramidIntegration, old_wsgi_call)
-        def sentry_patched_wsgi_call(self, environ, start_response):
-            # type: (Any, Dict[str, str], Callable[..., Any]) -> _ScopedResponse
-            def sentry_patched_inner_wsgi_call(environ, start_response):
-                # type: (Dict[str, Any], Callable[..., Any]) -> Any
+        def sentry_patched_wsgi_call(
+            self: Any, environ: Dict[str, str], start_response: Callable[..., Any]
+        ) -> _ScopedResponse:
+            def sentry_patched_inner_wsgi_call(
+                environ: Dict[str, Any], start_response: Callable[..., Any]
+            ) -> Any:
                 try:
                     return old_wsgi_call(self, environ, start_response)
                 except Exception:
@@ -137,8 +139,7 @@ class PyramidIntegration(Integration):
 
 
 @ensure_integration_enabled(PyramidIntegration)
-def _capture_exception(exc_info):
-    # type: (ExcInfo) -> None
+def _capture_exception(exc_info: ExcInfo) -> None:
     if exc_info[0] is None or issubclass(exc_info[0], HTTPException):
         return
 
@@ -151,8 +152,9 @@ def _capture_exception(exc_info):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _set_transaction_name_and_source(scope, transaction_style, request):
-    # type: (sentry_sdk.Scope, str, Request) -> None
+def _set_transaction_name_and_source(
+    scope: sentry_sdk.Scope, transaction_style: str, request: Request
+) -> None:
     try:
         name_for_style = {
             "route_name": request.matched_route.name,
@@ -167,40 +169,33 @@ def _set_transaction_name_and_source(scope, transaction_style, request):
 
 
 class PyramidRequestExtractor(RequestExtractor):
-    def url(self):
-        # type: () -> str
+    def url(self) -> str:
         return self.request.path_url
 
-    def env(self):
-        # type: () -> Dict[str, str]
+    def env(self) -> Dict[str, str]:
         return self.request.environ
 
-    def cookies(self):
-        # type: () -> RequestCookies
+    def cookies(self) -> RequestCookies:
         return self.request.cookies
 
-    def raw_data(self):
-        # type: () -> str
+    def raw_data(self) -> str:
         return self.request.text
 
-    def form(self):
-        # type: () -> Dict[str, str]
+    def form(self) -> Dict[str, str]:
         return {
             key: value
             for key, value in self.request.POST.items()
             if not getattr(value, "filename", None)
         }
 
-    def files(self):
-        # type: () -> Dict[str, _FieldStorageWithFile]
+    def files(self) -> Dict[str, _FieldStorageWithFile]:
         return {
             key: value
             for key, value in self.request.POST.items()
             if getattr(value, "filename", None)
         }
 
-    def size_of_file(self, postdata):
-        # type: (_FieldStorageWithFile) -> int
+    def size_of_file(self, postdata: _FieldStorageWithFile) -> int:
         file = postdata.file
         try:
             return os.fstat(file.fileno()).st_size
@@ -208,10 +203,10 @@ class PyramidRequestExtractor(RequestExtractor):
             return 0
 
 
-def _make_event_processor(weak_request, integration):
-    # type: (Callable[[], Request], PyramidIntegration) -> EventProcessor
-    def pyramid_event_processor(event, hint):
-        # type: (Event, Dict[str, Any]) -> Event
+def _make_event_processor(
+    weak_request: Callable[[], Request], integration: PyramidIntegration
+) -> EventProcessor:
+    def pyramid_event_processor(event: Event, hint: Dict[str, Any]) -> Event:
         request = weak_request()
         if request is None:
             return event

sentry_sdk/integrations/quart.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import asyncio
 import inspect
 from functools import wraps
@@ -60,8 +61,7 @@ class QuartIntegration(Integration):
 
     transaction_style = ""
 
-    def __init__(self, transaction_style="endpoint"):
-        # type: (str) -> None
+    def __init__(self, transaction_style: str = "endpoint") -> None:
         if transaction_style not in TRANSACTION_STYLE_VALUES:
             raise ValueError(
                 "Invalid value for transaction_style: %s (must be in %s)"
@@ -70,8 +70,7 @@ class QuartIntegration(Integration):
         self.transaction_style = transaction_style
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
 
         request_started.connect(_request_websocket_started)
         websocket_started.connect(_request_websocket_started)
@@ -83,12 +82,12 @@ class QuartIntegration(Integration):
         patch_scaffold_route()
 
 
-def patch_asgi_app():
-    # type: () -> None
+def patch_asgi_app() -> None:
     old_app = Quart.__call__
 
-    async def sentry_patched_asgi_app(self, scope, receive, send):
-        # type: (Any, Any, Any, Any) -> Any
+    async def sentry_patched_asgi_app(
+        self: Any, scope: Any, receive: Any, send: Any
+    ) -> Any:
         if sentry_sdk.get_client().get_integration(QuartIntegration) is None:
             return await old_app(self, scope, receive, send)
 
@@ -102,16 +101,13 @@ def patch_asgi_app():
     Quart.__call__ = sentry_patched_asgi_app
 
 
-def patch_scaffold_route():
-    # type: () -> None
+def patch_scaffold_route() -> None:
     old_route = Scaffold.route
 
-    def _sentry_route(*args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def _sentry_route(*args: Any, **kwargs: Any) -> Any:
         old_decorator = old_route(*args, **kwargs)
 
-        def decorator(old_func):
-            # type: (Any) -> Any
+        def decorator(old_func: Any) -> Any:
 
             if inspect.isfunction(old_func) and not asyncio.iscoroutinefunction(
                 old_func
@@ -119,8 +115,7 @@ def patch_scaffold_route():
 
                 @wraps(old_func)
                 @ensure_integration_enabled(QuartIntegration, old_func)
-                def _sentry_func(*args, **kwargs):
-                    # type: (*Any, **Any) -> Any
+                def _sentry_func(*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()
@@ -140,8 +135,9 @@ def patch_scaffold_route():
     Scaffold.route = _sentry_route
 
 
-def _set_transaction_name_and_source(scope, transaction_style, request):
-    # type: (sentry_sdk.Scope, str, Request) -> None
+def _set_transaction_name_and_source(
+    scope: sentry_sdk.Scope, transaction_style: str, request: Request
+) -> None:
 
     try:
         name_for_style = {
@@ -156,8 +152,7 @@ def _set_transaction_name_and_source(scope, transaction_style, request):
         pass
 
 
-async def _request_websocket_started(app, **kwargs):
-    # type: (Quart, **Any) -> None
+async def _request_websocket_started(app: Quart, **kwargs: Any) -> None:
     integration = sentry_sdk.get_client().get_integration(QuartIntegration)
     if integration is None:
         return
@@ -178,10 +173,10 @@ async def _request_websocket_started(app, **kwargs):
     scope.add_event_processor(evt_processor)
 
 
-def _make_request_event_processor(app, request, integration):
-    # type: (Quart, Request, QuartIntegration) -> EventProcessor
-    def inner(event, hint):
-        # type: (Event, dict[str, Any]) -> Event
+def _make_request_event_processor(
+    app: Quart, request: Request, integration: QuartIntegration
+) -> EventProcessor:
+    def inner(event: Event, hint: dict[str, Any]) -> Event:
         # if the request is gone we are fine not logging the data from
         # it.  This might happen if the processor is pushed away to
         # another thread.
@@ -207,8 +202,9 @@ def _make_request_event_processor(app, request, integration):
     return inner
 
 
-async def _capture_exception(sender, exception, **kwargs):
-    # type: (Quart, Union[ValueError, BaseException], **Any) -> None
+async def _capture_exception(
+    sender: Quart, exception: Union[ValueError, BaseException], **kwargs: Any
+) -> None:
     integration = sentry_sdk.get_client().get_integration(QuartIntegration)
     if integration is None:
         return
@@ -222,8 +218,7 @@ async def _capture_exception(sender, exception, **kwargs):
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _add_user_to_event(event):
-    # type: (Event) -> None
+def _add_user_to_event(event: Event) -> None:
     if quart_auth is None:
         return
 

sentry_sdk/integrations/ray.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import inspect
 import sys
 
@@ -29,8 +30,7 @@ if TYPE_CHECKING:
 DEFAULT_TRANSACTION_NAME = "unknown Ray function"
 
 
-def _check_sentry_initialized():
-    # type: () -> None
+def _check_sentry_initialized() -> None:
     if sentry_sdk.get_client().is_active():
         return
 
@@ -39,88 +39,98 @@ def _check_sentry_initialized():
     )
 
 
-def _patch_ray_remote():
-    # type: () -> None
+def _patch_ray_remote() -> None:
     old_remote = ray.remote
 
     @functools.wraps(old_remote)
-    def new_remote(f, *args, **kwargs):
-        # type: (Callable[..., Any], *Any, **Any) -> Callable[..., Any]
+    def new_remote(
+        f: Optional[Callable[..., Any]] = None, *args: Any, **kwargs: Any
+    ) -> Callable[..., Any]:
+
         if inspect.isclass(f):
             # Ray Actors
             # (https://docs.ray.io/en/latest/ray-core/actors.html)
             # are not supported
             # (Only Ray Tasks are supported)
-            return old_remote(f, *args, *kwargs)
-
-        def _f(*f_args, _tracing=None, **f_kwargs):
-            # type: (Any, Optional[dict[str, Any]],  Any) -> Any
-            """
-            Ray Worker
-            """
-            _check_sentry_initialized()
-
-            root_span_name = qualname_from_function(f) or DEFAULT_TRANSACTION_NAME
-            sentry_sdk.get_current_scope().set_transaction_name(
-                root_span_name,
-                source=TransactionSource.TASK,
-            )
-            with sentry_sdk.continue_trace(_tracing or {}):
+            return old_remote(f, *args, **kwargs)
+
+        def wrapper(user_f: Callable[..., Any]) -> Any:
+            def new_func(
+                *f_args: Any, _tracing: Optional[dict[str, Any]] = None, **f_kwargs: Any
+            ) -> Any:
+                _check_sentry_initialized()
+
+                root_span_name = (
+                    qualname_from_function(user_f) or DEFAULT_TRANSACTION_NAME
+                )
+                sentry_sdk.get_current_scope().set_transaction_name(
+                    root_span_name,
+                    source=TransactionSource.TASK,
+                )
+                with sentry_sdk.continue_trace(_tracing or {}):
+                    with sentry_sdk.start_span(
+                        op=OP.QUEUE_TASK_RAY,
+                        name=qualname_from_function(user_f),
+                        origin=RayIntegration.origin,
+                        source=TransactionSource.TASK,
+                    ) as root_span:
+                        try:
+                            result = user_f(*f_args, **f_kwargs)
+                            root_span.set_status(SPANSTATUS.OK)
+                        except Exception:
+                            root_span.set_status(SPANSTATUS.INTERNAL_ERROR)
+                            exc_info = sys.exc_info()
+                            _capture_exception(exc_info)
+                            reraise(*exc_info)
+
+                        return result
+
+            if f:
+                rv = old_remote(new_func)
+            else:
+                rv = old_remote(*args, **kwargs)(new_func)
+            old_remote_method = rv.remote
+
+            def _remote_method_with_header_propagation(
+                *args: Any, **kwargs: Any
+            ) -> Any:
+                """
+                Ray Client
+                """
                 with sentry_sdk.start_span(
-                    op=OP.QUEUE_TASK_RAY,
-                    name=root_span_name,
+                    op=OP.QUEUE_SUBMIT_RAY,
+                    name=qualname_from_function(user_f),
                     origin=RayIntegration.origin,
-                    source=TransactionSource.TASK,
-                ) as root_span:
+                    only_if_parent=True,
+                ) as span:
+                    tracing = {
+                        k: v
+                        for k, v in sentry_sdk.get_current_scope().iter_trace_propagation_headers()
+                    }
                     try:
-                        result = f(*f_args, **f_kwargs)
-                        root_span.set_status(SPANSTATUS.OK)
+                        result = old_remote_method(*args, **kwargs, _tracing=tracing)
+                        span.set_status(SPANSTATUS.OK)
                     except Exception:
-                        root_span.set_status(SPANSTATUS.INTERNAL_ERROR)
+                        span.set_status(SPANSTATUS.INTERNAL_ERROR)
                         exc_info = sys.exc_info()
                         _capture_exception(exc_info)
                         reraise(*exc_info)
 
                     return result
 
-        rv = old_remote(_f, *args, *kwargs)
-        old_remote_method = rv.remote
-
-        def _remote_method_with_header_propagation(*args, **kwargs):
-            # type: (*Any, **Any) -> Any
-            """
-            Ray Client
-            """
-            with sentry_sdk.start_span(
-                op=OP.QUEUE_SUBMIT_RAY,
-                name=qualname_from_function(f),
-                origin=RayIntegration.origin,
-                only_if_parent=True,
-            ) as span:
-                tracing = {
-                    k: v
-                    for k, v in sentry_sdk.get_current_scope().iter_trace_propagation_headers()
-                }
-                try:
-                    result = old_remote_method(*args, **kwargs, _tracing=tracing)
-                    span.set_status(SPANSTATUS.OK)
-                except Exception:
-                    span.set_status(SPANSTATUS.INTERNAL_ERROR)
-                    exc_info = sys.exc_info()
-                    _capture_exception(exc_info)
-                    reraise(*exc_info)
-
-                return result
-
-        rv.remote = _remote_method_with_header_propagation
-
-        return rv
+            rv.remote = _remote_method_with_header_propagation
+
+            return rv
+
+        if f is not None:
+            return wrapper(f)
+        else:
+            return wrapper
 
     ray.remote = new_remote
 
 
-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(
@@ -139,8 +149,7 @@ class RayIntegration(Integration):
     origin = f"auto.queue.{identifier}"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         version = package_version("ray")
         _check_minimum_version(RayIntegration, version)
 

sentry_sdk/integrations/redis/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from sentry_sdk.integrations import Integration, DidNotEnable
 from sentry_sdk.integrations.redis.consts import _DEFAULT_MAX_DATA_SIZE
 from sentry_sdk.integrations.redis.rb import _patch_rb
@@ -15,14 +16,16 @@ if TYPE_CHECKING:
 class RedisIntegration(Integration):
     identifier = "redis"
 
-    def __init__(self, max_data_size=_DEFAULT_MAX_DATA_SIZE, cache_prefixes=None):
-        # type: (int, Optional[list[str]]) -> None
+    def __init__(
+        self,
+        max_data_size: int = _DEFAULT_MAX_DATA_SIZE,
+        cache_prefixes: Optional[list[str]] = None,
+    ) -> None:
         self.max_data_size = max_data_size
         self.cache_prefixes = cache_prefixes if cache_prefixes is not None else []
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         try:
             from redis import StrictRedis, client
         except ImportError:

sentry_sdk/integrations/redis/_async_common.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations.redis.consts import SPAN_ORIGIN
@@ -24,15 +25,16 @@ if TYPE_CHECKING:
 
 
 def patch_redis_async_pipeline(
-    pipeline_cls, is_cluster, get_command_args_fn, get_db_data_fn
-):
-    # type: (Union[type[Pipeline[Any]], type[ClusterPipeline[Any]]], bool, Any, Callable[[Any], dict[str, Any]]) -> None
+    pipeline_cls: Union[type[Pipeline[Any]], type[ClusterPipeline[Any]]],
+    is_cluster: bool,
+    get_command_args_fn: Any,
+    get_db_data_fn: Callable[[Any], dict[str, Any]],
+) -> None:
     old_execute = pipeline_cls.execute
 
     from sentry_sdk.integrations.redis import RedisIntegration
 
-    async def _sentry_execute(self, *args, **kwargs):
-        # type: (Any, *Any, **Any) -> Any
+    async def _sentry_execute(self: Any, *args: Any, **kwargs: Any) -> Any:
         if sentry_sdk.get_client().get_integration(RedisIntegration) is None:
             return await old_execute(self, *args, **kwargs)
 
@@ -44,13 +46,20 @@ def patch_redis_async_pipeline(
         ) as span:
             with capture_internal_exceptions():
                 span_data = get_db_data_fn(self)
+
+                try:
+                    command_seq = self._execution_strategy._command_queue
+                except AttributeError:
+                    if is_cluster:
+                        command_seq = self._command_stack
+                    else:
+                        command_seq = self.command_stack
+
                 pipeline_data = _get_pipeline_data(
                     is_cluster=is_cluster,
                     get_command_args_fn=get_command_args_fn,
                     is_transaction=False if is_cluster else self.is_transaction,
-                    command_stack=(
-                        self._command_stack if is_cluster else self.command_stack
-                    ),
+                    command_seq=command_seq,
                 )
                 _update_span(span, span_data, pipeline_data)
                 _create_breadcrumb("redis.pipeline.execute", span_data, pipeline_data)
@@ -60,14 +69,18 @@ def patch_redis_async_pipeline(
     pipeline_cls.execute = _sentry_execute  # type: ignore
 
 
-def patch_redis_async_client(cls, is_cluster, get_db_data_fn):
-    # type: (Union[type[StrictRedis[Any]], type[RedisCluster[Any]]], bool, Callable[[Any], dict[str, Any]]) -> None
+def patch_redis_async_client(
+    cls: Union[type[StrictRedis[Any]], type[RedisCluster[Any]]],
+    is_cluster: bool,
+    get_db_data_fn: Callable[[Any], dict[str, Any]],
+) -> None:
     old_execute_command = cls.execute_command
 
     from sentry_sdk.integrations.redis import RedisIntegration
 
-    async def _sentry_execute_command(self, name, *args, **kwargs):
-        # type: (Any, str, *Any, **Any) -> Any
+    async def _sentry_execute_command(
+        self: Any, name: str, *args: Any, **kwargs: Any
+    ) -> Any:
         integration = sentry_sdk.get_client().get_integration(RedisIntegration)
         if integration is None:
             return await old_execute_command(self, name, *args, **kwargs)

sentry_sdk/integrations/redis/_sync_common.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations.redis.consts import SPAN_ORIGIN
@@ -22,18 +23,16 @@ if TYPE_CHECKING:
 
 
 def patch_redis_pipeline(
-    pipeline_cls,
-    is_cluster,
-    get_command_args_fn,
-    get_db_data_fn,
-):
-    # type: (Any, bool, Any, Callable[[Any], dict[str, Any]]) -> None
+    pipeline_cls: Any,
+    is_cluster: bool,
+    get_command_args_fn: Any,
+    get_db_data_fn: Callable[[Any], dict[str, Any]],
+) -> None:
     old_execute = pipeline_cls.execute
 
     from sentry_sdk.integrations.redis import RedisIntegration
 
-    def sentry_patched_execute(self, *args, **kwargs):
-        # type: (Any, *Any, **Any) -> Any
+    def sentry_patched_execute(self: Any, *args: Any, **kwargs: Any) -> Any:
         if sentry_sdk.get_client().get_integration(RedisIntegration) is None:
             return old_execute(self, *args, **kwargs)
 
@@ -44,12 +43,17 @@ def patch_redis_pipeline(
             only_if_parent=True,
         ) as span:
             with capture_internal_exceptions():
+                try:
+                    command_seq = self._execution_strategy.command_queue
+                except AttributeError:
+                    command_seq = self.command_stack
+
                 span_data = get_db_data_fn(self)
                 pipeline_data = _get_pipeline_data(
                     is_cluster=is_cluster,
                     get_command_args_fn=get_command_args_fn,
                     is_transaction=False if is_cluster else self.transaction,
-                    command_stack=self.command_stack,
+                    command_seq=command_seq,
                 )
                 _update_span(span, span_data, pipeline_data)
                 _create_breadcrumb("redis.pipeline.execute", span_data, pipeline_data)
@@ -59,8 +63,9 @@ def patch_redis_pipeline(
     pipeline_cls.execute = sentry_patched_execute
 
 
-def patch_redis_client(cls, is_cluster, get_db_data_fn):
-    # type: (Any, bool, Callable[[Any], dict[str, Any]]) -> None
+def patch_redis_client(
+    cls: Any, is_cluster: bool, get_db_data_fn: Callable[[Any], dict[str, Any]]
+) -> None:
     """
     This function can be used to instrument custom redis client classes or
     subclasses.
@@ -69,8 +74,9 @@ def patch_redis_client(cls, is_cluster, get_db_data_fn):
 
     from sentry_sdk.integrations.redis import RedisIntegration
 
-    def sentry_patched_execute_command(self, name, *args, **kwargs):
-        # type: (Any, str, *Any, **Any) -> Any
+    def sentry_patched_execute_command(
+        self: Any, name: str, *args: Any, **kwargs: Any
+    ) -> Any:
         integration = sentry_sdk.get_client().get_integration(RedisIntegration)
         if integration is None:
             return old_execute_command(self, name, *args, **kwargs)