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

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_as_child_span=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)
 
@@ -40,7 +42,7 @@ def patch_redis_async_pipeline(
             op=OP.DB_REDIS,
             name="redis.pipeline.execute",
             origin=SPAN_ORIGIN,
-            only_if_parent=True,
+            only_as_child_span=True,
         ) as span:
             with capture_internal_exceptions():
                 span_data = get_db_data_fn(self)
@@ -67,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)
@@ -92,7 +98,7 @@ def patch_redis_async_client(cls, is_cluster, get_db_data_fn):
                 op=cache_properties["op"],
                 name=cache_properties["description"],
                 origin=SPAN_ORIGIN,
-                only_if_parent=True,
+                only_as_child_span=True,
             )
             cache_span.__enter__()
 
@@ -102,7 +108,7 @@ def patch_redis_async_client(cls, is_cluster, get_db_data_fn):
             op=db_properties["op"],
             name=db_properties["description"],
             origin=SPAN_ORIGIN,
-            only_if_parent=True,
+            only_as_child_span=True,
         )
         db_span.__enter__()
 

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)
 
@@ -41,7 +40,7 @@ def patch_redis_pipeline(
             op=OP.DB_REDIS,
             name="redis.pipeline.execute",
             origin=SPAN_ORIGIN,
-            only_if_parent=True,
+            only_as_child_span=True,
         ) as span:
             with capture_internal_exceptions():
                 try:
@@ -64,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.
@@ -74,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)
@@ -93,7 +94,7 @@ def patch_redis_client(cls, is_cluster, get_db_data_fn):
                 op=cache_properties["op"],
                 name=cache_properties["description"],
                 origin=SPAN_ORIGIN,
-                only_if_parent=True,
+                only_as_child_span=True,
             )
             cache_span.__enter__()
 
@@ -103,7 +104,7 @@ def patch_redis_client(cls, is_cluster, get_db_data_fn):
             op=db_properties["op"],
             name=db_properties["description"],
             origin=SPAN_ORIGIN,
-            only_if_parent=True,
+            only_as_child_span=True,
         )
         db_span.__enter__()
 

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,8 +37,9 @@ 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():
         client = getattr(async_redis_cluster_pipeline_instance, "cluster_client", None)
         if client is None:
@@ -50,8 +54,7 @@ def _get_async_cluster_pipeline_db_data(async_redis_cluster_pipeline_instance):
         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:
@@ -64,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: