sentry-sdk 2.26.1__py2.py3-none-any.whl → 3.0.0a1__py2.py3-none-any.whl

sentry_sdk/integrations/redis/rb.py

@@ -5,7 +5,7 @@ https://github.com/getsentry/rb
 """
 
 from sentry_sdk.integrations.redis._sync_common import patch_redis_client
-from sentry_sdk.integrations.redis.modules.queries import _set_db_data
+from sentry_sdk.integrations.redis.modules.queries import _get_db_data
 
 
 def _patch_rb():
@@ -18,15 +18,15 @@ def _patch_rb():
         patch_redis_client(
             rb.clients.FanoutClient,
             is_cluster=False,
-            set_db_data_fn=_set_db_data,
+            get_db_data_fn=_get_db_data,
         )
         patch_redis_client(
             rb.clients.MappingClient,
             is_cluster=False,
-            set_db_data_fn=_set_db_data,
+            get_db_data_fn=_get_db_data,
         )
         patch_redis_client(
             rb.clients.RoutingClient,
             is_cluster=False,
-            set_db_data_fn=_set_db_data,
+            get_db_data_fn=_get_db_data,
         )

sentry_sdk/integrations/redis/redis.py

@@ -8,7 +8,7 @@ from sentry_sdk.integrations.redis._sync_common import (
     patch_redis_client,
     patch_redis_pipeline,
 )
-from sentry_sdk.integrations.redis.modules.queries import _set_db_data
+from sentry_sdk.integrations.redis.modules.queries import _get_db_data
 
 from typing import TYPE_CHECKING
 
@@ -26,13 +26,13 @@ def _patch_redis(StrictRedis, client):  # noqa: N803
     patch_redis_client(
         StrictRedis,
         is_cluster=False,
-        set_db_data_fn=_set_db_data,
+        get_db_data_fn=_get_db_data,
     )
     patch_redis_pipeline(
         client.Pipeline,
         is_cluster=False,
         get_command_args_fn=_get_redis_command_args,
-        set_db_data_fn=_set_db_data,
+        get_db_data_fn=_get_db_data,
     )
     try:
         strict_pipeline = client.StrictPipeline
@@ -43,7 +43,7 @@ def _patch_redis(StrictRedis, client):  # noqa: N803
             strict_pipeline,
             is_cluster=False,
             get_command_args_fn=_get_redis_command_args,
-            set_db_data_fn=_set_db_data,
+            get_db_data_fn=_get_db_data,
         )
 
     try:
@@ -59,11 +59,11 @@ def _patch_redis(StrictRedis, client):  # noqa: N803
         patch_redis_async_client(
             redis.asyncio.client.StrictRedis,
             is_cluster=False,
-            set_db_data_fn=_set_db_data,
+            get_db_data_fn=_get_db_data,
         )
         patch_redis_async_pipeline(
             redis.asyncio.client.Pipeline,
             False,
             _get_redis_command_args,
-            set_db_data_fn=_set_db_data,
+            get_db_data_fn=_get_db_data,
         )

sentry_sdk/integrations/redis/redis_cluster.py

@@ -9,7 +9,7 @@ from sentry_sdk.integrations.redis._sync_common import (
     patch_redis_client,
     patch_redis_pipeline,
 )
-from sentry_sdk.integrations.redis.modules.queries import _set_db_data_on_span
+from sentry_sdk.integrations.redis.modules.queries import _get_connection_data
 from sentry_sdk.integrations.redis.utils import _parse_rediscluster_command
 
 from sentry_sdk.utils import capture_internal_exceptions
@@ -23,29 +23,29 @@ if TYPE_CHECKING:
         RedisCluster as AsyncRedisCluster,
         ClusterPipeline as AsyncClusterPipeline,
     )
-    from sentry_sdk.tracing import Span
 
 
-def _set_async_cluster_db_data(span, async_redis_cluster_instance):
-    # type: (Span, AsyncRedisCluster[Any]) -> None
+def _get_async_cluster_db_data(async_redis_cluster_instance):
+    # type: (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:
-        _set_db_data_on_span(span, default_node.connection_kwargs)
+        return _get_connection_data(default_node.connection_kwargs)
+    else:
+        return {}
 
 
-def _set_async_cluster_pipeline_db_data(span, async_redis_cluster_pipeline_instance):
-    # type: (Span, AsyncClusterPipeline[Any]) -> None
+def _get_async_cluster_pipeline_db_data(async_redis_cluster_pipeline_instance):
+    # type: (AsyncClusterPipeline[Any]) -> dict[str, Any]
     with capture_internal_exceptions():
-        _set_async_cluster_db_data(
-            span,
+        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]
         )
 
 
-def _set_cluster_db_data(span, redis_cluster_instance):
-    # type: (Span, RedisCluster[Any]) -> None
+def _get_cluster_db_data(redis_cluster_instance):
+    # type: (RedisCluster[Any]) -> dict[str, Any]
     default_node = redis_cluster_instance.get_default_node()
 
     if default_node is not None:
@@ -53,7 +53,9 @@ def _set_cluster_db_data(span, redis_cluster_instance):
             "host": default_node.host,
             "port": default_node.port,
         }
-        _set_db_data_on_span(span, connection_params)
+        return _get_connection_data(connection_params)
+    else:
+        return {}
 
 
 def _patch_redis_cluster():
@@ -67,13 +69,13 @@ def _patch_redis_cluster():
         patch_redis_client(
             RedisCluster,
             is_cluster=True,
-            set_db_data_fn=_set_cluster_db_data,
+            get_db_data_fn=_get_cluster_db_data,
         )
         patch_redis_pipeline(
             cluster.ClusterPipeline,
             is_cluster=True,
             get_command_args_fn=_parse_rediscluster_command,
-            set_db_data_fn=_set_cluster_db_data,
+            get_db_data_fn=_get_cluster_db_data,
         )
 
     try:
@@ -89,11 +91,11 @@ def _patch_redis_cluster():
         patch_redis_async_client(
             async_cluster.RedisCluster,
             is_cluster=True,
-            set_db_data_fn=_set_async_cluster_db_data,
+            get_db_data_fn=_get_async_cluster_db_data,
         )
         patch_redis_async_pipeline(
             async_cluster.ClusterPipeline,
             is_cluster=True,
             get_command_args_fn=_parse_rediscluster_command,
-            set_db_data_fn=_set_async_cluster_pipeline_db_data,
+            get_db_data_fn=_get_async_cluster_pipeline_db_data,
         )

sentry_sdk/integrations/redis/redis_py_cluster_legacy.py

@@ -9,7 +9,7 @@ from sentry_sdk.integrations.redis._sync_common import (
     patch_redis_client,
     patch_redis_pipeline,
 )
-from sentry_sdk.integrations.redis.modules.queries import _set_db_data
+from sentry_sdk.integrations.redis.modules.queries import _get_db_data
 from sentry_sdk.integrations.redis.utils import _parse_rediscluster_command
 
 
@@ -23,7 +23,7 @@ def _patch_rediscluster():
     patch_redis_client(
         rediscluster.RedisCluster,
         is_cluster=True,
-        set_db_data_fn=_set_db_data,
+        get_db_data_fn=_get_db_data,
     )
 
     # up to v1.3.6, __version__ attribute is a tuple
@@ -37,7 +37,7 @@ def _patch_rediscluster():
         patch_redis_client(
             rediscluster.StrictRedisCluster,
             is_cluster=True,
-            set_db_data_fn=_set_db_data,
+            get_db_data_fn=_get_db_data,
         )
     else:
         pipeline_cls = rediscluster.pipeline.ClusterPipeline
@@ -46,5 +46,5 @@ def _patch_rediscluster():
         pipeline_cls,
         is_cluster=True,
         get_command_args_fn=_parse_rediscluster_command,
-        set_db_data_fn=_set_db_data,
+        get_db_data_fn=_get_db_data,
     )

sentry_sdk/integrations/redis/utils.py

@@ -1,3 +1,4 @@
+import sentry_sdk
 from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations.redis.consts import (
     _COMMANDS_INCLUDING_SENSITIVE_DATA,
@@ -16,6 +17,47 @@ if TYPE_CHECKING:
     from sentry_sdk.tracing import Span
 
 
+TAG_KEYS = [
+    "redis.command",
+    "redis.is_cluster",
+    "redis.key",
+    "redis.transaction",
+    SPANDATA.DB_OPERATION,
+]
+
+
+def _update_span(span, *data_bags):
+    # type: (Span, *dict[str, Any]) -> None
+    """
+    Set tags and data on the given span to data from the given data bags.
+    """
+    for data in data_bags:
+        for key, value in data.items():
+            if key in TAG_KEYS:
+                span.set_tag(key, value)
+            else:
+                span.set_attribute(key, value)
+
+
+def _create_breadcrumb(message, *data_bags):
+    # type: (str, *dict[str, Any]) -> None
+    """
+    Create a breadcrumb containing the tags data from the given data bags.
+    """
+    data = {}
+    for data in data_bags:
+        for key, value in data.items():
+            if key in TAG_KEYS:
+                data[key] = value
+
+    sentry_sdk.add_breadcrumb(
+        message=message,
+        type="redis",
+        category="redis",
+        data=data,
+    )
+
+
 def _get_safe_command(name, args):
     # type: (str, Sequence[Any]) -> str
     command_parts = [name]
@@ -105,12 +147,12 @@ def _parse_rediscluster_command(command):
     return command.args
 
 
-def _set_pipeline_data(
-    span, is_cluster, get_command_args_fn, is_transaction, command_stack
-):
-    # type: (Span, bool, Any, bool, Sequence[Any]) -> None
-    span.set_tag("redis.is_cluster", is_cluster)
-    span.set_tag("redis.transaction", is_transaction)
+def _get_pipeline_data(is_cluster, get_command_args_fn, is_transaction, command_stack):
+    # type: (bool, Any, bool, Sequence[Any]) -> dict[str, Any]
+    data = {
+        "redis.is_cluster": is_cluster,
+        "redis.transaction": is_transaction,
+    }  # type: dict[str, Any]
 
     commands = []
     for i, arg in enumerate(command_stack):
@@ -120,25 +162,27 @@ def _set_pipeline_data(
         command = get_command_args_fn(arg)
         commands.append(_get_safe_command(command[0], command[1:]))
 
-    span.set_data(
-        "redis.commands",
-        {
-            "count": len(command_stack),
-            "first_ten": commands,
-        },
-    )
+    data["redis.commands.count"] = len(command_stack)
+    data["redis.commands.first_ten"] = commands
+
+    return data
 
 
-def _set_client_data(span, is_cluster, name, *args):
-    # type: (Span, bool, str, *Any) -> None
-    span.set_tag("redis.is_cluster", is_cluster)
+def _get_client_data(is_cluster, name, *args):
+    # type: (bool, str, *Any) -> dict[str, Any]
+    data = {
+        "redis.is_cluster": is_cluster,
+    }  # type: dict[str, Any]
+
     if name:
-        span.set_tag("redis.command", name)
-        span.set_tag(SPANDATA.DB_OPERATION, name)
+        data["redis.command"] = name
+        data[SPANDATA.DB_OPERATION] = name
 
     if name and args:
         name_low = name.lower()
         if (name_low in _SINGLE_KEY_COMMANDS) or (
             name_low in _MULTI_KEY_COMMANDS and len(args) == 1
         ):
-            span.set_tag("redis.key", args[0])
+            data["redis.key"] = args[0]
+
+    return data

sentry_sdk/integrations/rq.py

@@ -2,7 +2,6 @@ import weakref
 
 import sentry_sdk
 from sentry_sdk.consts import OP
-from sentry_sdk.api import continue_trace
 from sentry_sdk.integrations import _check_minimum_version, DidNotEnable, Integration
 from sentry_sdk.integrations.logging import ignore_logger
 from sentry_sdk.tracing import TransactionSource
@@ -33,6 +32,17 @@ if TYPE_CHECKING:
 
     from rq.job import Job
 
+DEFAULT_TRANSACTION_NAME = "unknown RQ task"
+
+
+JOB_PROPERTY_TO_ATTRIBUTE = {
+    "id": "messaging.message.id",
+}
+
+QUEUE_PROPERTY_TO_ATTRIBUTE = {
+    "name": "messaging.destination.name",
+}
+
 
 class RqIntegration(Integration):
     identifier = "rq"
@@ -47,28 +57,31 @@ class RqIntegration(Integration):
         old_perform_job = Worker.perform_job
 
         @ensure_integration_enabled(RqIntegration, old_perform_job)
-        def sentry_patched_perform_job(self, job, *args, **kwargs):
-            # type: (Any, Job, *Queue, **Any) -> bool
+        def sentry_patched_perform_job(self, job, queue, *args, **kwargs):
+            # type: (Any, Job, Queue, *Any, **Any) -> bool
             with sentry_sdk.new_scope() as scope:
-                scope.clear_breadcrumbs()
-                scope.add_event_processor(_make_event_processor(weakref.ref(job)))
+                try:
+                    transaction_name = job.func_name or DEFAULT_TRANSACTION_NAME
+                except AttributeError:
+                    transaction_name = DEFAULT_TRANSACTION_NAME
 
-                transaction = continue_trace(
-                    job.meta.get("_sentry_trace_headers") or {},
-                    op=OP.QUEUE_TASK_RQ,
-                    name="unknown RQ task",
-                    source=TransactionSource.TASK,
-                    origin=RqIntegration.origin,
+                scope.set_transaction_name(
+                    transaction_name, source=TransactionSource.TASK
                 )
+                scope.clear_breadcrumbs()
+                scope.add_event_processor(_make_event_processor(weakref.ref(job)))
 
-                with capture_internal_exceptions():
-                    transaction.name = job.func_name
-
-                with sentry_sdk.start_transaction(
-                    transaction,
-                    custom_sampling_context={"rq_job": job},
+                with sentry_sdk.continue_trace(
+                    job.meta.get("_sentry_trace_headers") or {}
                 ):
-                    rv = old_perform_job(self, job, *args, **kwargs)
+                    with sentry_sdk.start_span(
+                        op=OP.QUEUE_TASK_RQ,
+                        name=transaction_name,
+                        source=TransactionSource.TASK,
+                        origin=RqIntegration.origin,
+                        attributes=_prepopulate_attributes(job, queue),
+                    ):
+                        rv = old_perform_job(self, job, queue, *args, **kwargs)
 
             if self.is_horse:
                 # We're inside of a forked process and RQ is
@@ -102,11 +115,9 @@ class RqIntegration(Integration):
         @ensure_integration_enabled(RqIntegration, old_enqueue_job)
         def sentry_patched_enqueue_job(self, job, **kwargs):
             # type: (Queue, Any, **Any) -> Any
-            scope = sentry_sdk.get_current_scope()
-            if scope.span is not None:
-                job.meta["_sentry_trace_headers"] = dict(
-                    scope.iter_trace_propagation_headers()
-                )
+            job.meta["_sentry_trace_headers"] = dict(
+                sentry_sdk.get_current_scope().iter_trace_propagation_headers()
+            )
 
             return old_enqueue_job(self, job, **kwargs)
 
@@ -159,3 +170,37 @@ def _capture_exception(exc_info, **kwargs):
     )
 
     sentry_sdk.capture_event(event, hint=hint)
+
+
+def _prepopulate_attributes(job, queue):
+    # type: (Job, Queue) -> dict[str, Any]
+    attributes = {
+        "messaging.system": "rq",
+        "rq.job.id": job.id,
+    }
+
+    for prop, attr in JOB_PROPERTY_TO_ATTRIBUTE.items():
+        if getattr(job, prop, None) is not None:
+            attributes[attr] = getattr(job, prop)
+
+    for prop, attr in QUEUE_PROPERTY_TO_ATTRIBUTE.items():
+        if getattr(queue, prop, None) is not None:
+            attributes[attr] = getattr(queue, prop)
+
+    if getattr(job, "args", None):
+        for i, arg in enumerate(job.args):
+            with capture_internal_exceptions():
+                attributes[f"rq.job.args.{i}"] = str(arg)
+
+    if getattr(job, "kwargs", None):
+        for kwarg, value in job.kwargs.items():
+            with capture_internal_exceptions():
+                attributes[f"rq.job.kwargs.{kwarg}"] = str(value)
+
+    func = job.func
+    if callable(func):
+        func = func.__name__
+
+    attributes["rq.job.func"] = str(func)
+
+    return attributes

sentry_sdk/integrations/rust_tracing.py

@@ -32,16 +32,14 @@ Each native extension requires its own integration.
 
 import json
 from enum import Enum, auto
-from typing import Any, Callable, Dict, Tuple, Optional
+from typing import Any, Callable, Dict, Optional
 
 import sentry_sdk
 from sentry_sdk.integrations import Integration
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import Span as SentrySpan
+from sentry_sdk.tracing import Span
 from sentry_sdk.utils import SENSITIVE_DATA_SUBSTITUTE
 
-TraceState = Optional[Tuple[Optional[SentrySpan], SentrySpan]]
-
 
 class RustTracingLevel(Enum):
     Trace = "TRACE"
@@ -171,7 +169,7 @@ class RustTracingLayer:
             else self.include_tracing_fields
         )
 
-    def on_event(self, event: str, _span_state: TraceState) -> None:
+    def on_event(self, event: str, _span_state: Optional[Span]) -> None:
         deserialized_event = json.loads(event)
         metadata = deserialized_event.get("metadata", {})
 
@@ -185,7 +183,7 @@ class RustTracingLayer:
         elif event_type == EventTypeMapping.Event:
             process_event(deserialized_event)
 
-    def on_new_span(self, attrs: str, span_id: str) -> TraceState:
+    def on_new_span(self, attrs: str, span_id: str) -> Optional[Span]:
         attrs = json.loads(attrs)
         metadata = attrs.get("metadata", {})
 
@@ -205,48 +203,35 @@ class RustTracingLayer:
         else:
             sentry_span_name = "<unknown>"
 
-        kwargs = {
-            "op": "function",
-            "name": sentry_span_name,
-            "origin": self.origin,
-        }
-
-        scope = sentry_sdk.get_current_scope()
-        parent_sentry_span = scope.span
-        if parent_sentry_span:
-            sentry_span = parent_sentry_span.start_child(**kwargs)
-        else:
-            sentry_span = scope.start_span(**kwargs)
+        span = sentry_sdk.start_span(
+            op="function",
+            name=sentry_span_name,
+            origin=self.origin,
+            only_if_parent=True,
+        )
+        span.__enter__()
 
         fields = metadata.get("fields", [])
         for field in fields:
             if self._include_tracing_fields():
-                sentry_span.set_data(field, attrs.get(field))
-            else:
-                sentry_span.set_data(field, SENSITIVE_DATA_SUBSTITUTE)
-
-        scope.span = sentry_span
-        return (parent_sentry_span, sentry_span)
-
-    def on_close(self, span_id: str, span_state: TraceState) -> None:
-        if span_state is None:
-            return
-
-        parent_sentry_span, sentry_span = span_state
-        sentry_span.finish()
-        sentry_sdk.get_current_scope().span = parent_sentry_span
-
-    def on_record(self, span_id: str, values: str, span_state: TraceState) -> None:
-        if span_state is None:
-            return
-        _parent_sentry_span, sentry_span = span_state
-
-        deserialized_values = json.loads(values)
-        for key, value in deserialized_values.items():
-            if self._include_tracing_fields():
-                sentry_span.set_data(key, value)
+                span.set_attribute(field, attrs.get(field))
             else:
-                sentry_span.set_data(key, SENSITIVE_DATA_SUBSTITUTE)
+                span.set_attribute(field, SENSITIVE_DATA_SUBSTITUTE)
+
+        return span
+
+    def on_close(self, span_id: str, span: Optional[Span]) -> None:
+        if span is not None:
+            span.__exit__(None, None, None)
+
+    def on_record(self, span_id: str, values: str, span: Optional[Span]) -> None:
+        if span is not None:
+            deserialized_values = json.loads(values)
+            for key, value in deserialized_values.items():
+                if self._include_tracing_fields():
+                    span.set_attribute(key, value)
+                else:
+                    span.set_attribute(key, SENSITIVE_DATA_SUBSTITUTE)
 
 
 class RustTracingIntegration(Integration):

sentry_sdk/integrations/sanic.py

@@ -4,7 +4,6 @@ from inspect import isawaitable
 from urllib.parse import urlsplit
 
 import sentry_sdk
-from sentry_sdk import continue_trace
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
 from sentry_sdk.integrations._wsgi_common import RequestExtractor, _filter_headers
@@ -182,21 +181,25 @@ async def _context_enter(request):
         return
 
     weak_request = weakref.ref(request)
-    request.ctx._sentry_scope = sentry_sdk.isolation_scope()
-    scope = request.ctx._sentry_scope.__enter__()
+    request.ctx._sentry_scope_manager = sentry_sdk.isolation_scope()
+    scope = request.ctx._sentry_scope_manager.__enter__()
+    request.ctx._sentry_scope = scope
+
+    scope.set_transaction_name(request.path, TransactionSource.URL)
     scope.clear_breadcrumbs()
     scope.add_event_processor(_make_request_processor(weak_request))
 
-    transaction = continue_trace(
-        dict(request.headers),
+    # TODO-neel-potel test if this works
+    request.ctx._sentry_continue_trace = sentry_sdk.continue_trace(
+        dict(request.headers)
+    )
+    request.ctx._sentry_continue_trace.__enter__()
+    request.ctx._sentry_transaction = sentry_sdk.start_span(
         op=OP.HTTP_SERVER,
         # Unless the request results in a 404 error, the name and source will get overwritten in _set_transaction
         name=request.path,
         source=TransactionSource.URL,
         origin=SanicIntegration.origin,
-    )
-    request.ctx._sentry_transaction = sentry_sdk.start_transaction(
-        transaction
     ).__enter__()
 
 
@@ -211,16 +214,23 @@ async def _context_exit(request, response=None):
         response_status = None if response is None else response.status
 
         # This capture_internal_exceptions block has been intentionally nested here, so that in case an exception
-        # happens while trying to end the transaction, we still attempt to exit the hub.
+        # happens while trying to end the transaction, we still attempt to exit the scope.
         with capture_internal_exceptions():
             request.ctx._sentry_transaction.set_http_status(response_status)
-            request.ctx._sentry_transaction.sampled &= (
+
+            if (
                 isinstance(integration, SanicIntegration)
-                and response_status not in integration._unsampled_statuses
-            )
+                and response_status in integration._unsampled_statuses
+            ):
+                # drop the event in an event processor
+                request.ctx._sentry_scope.add_event_processor(
+                    lambda _event, _hint: None
+                )
+
             request.ctx._sentry_transaction.__exit__(None, None, None)
+            request.ctx._sentry_continue_trace.__exit__(None, None, None)
 
-        request.ctx._sentry_scope.__exit__(None, None, None)
+        request.ctx._sentry_scope_manager.__exit__(None, None, None)
 
 
 async def _set_transaction(request, route, **_):

sentry_sdk/integrations/socket.py

@@ -61,10 +61,13 @@ def _patch_create_connection():
             op=OP.SOCKET_CONNECTION,
             name=_get_span_description(address[0], address[1]),
             origin=SocketIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data("address", address)
-            span.set_data("timeout", timeout)
-            span.set_data("source_address", source_address)
+            host, port = address
+            span.set_attribute("address.host", host)
+            span.set_attribute("address.port", port)
+            span.set_attribute("timeout", timeout)
+            span.set_attribute("source_address", source_address)
 
             return real_create_connection(
                 address=address, timeout=timeout, source_address=source_address
@@ -87,9 +90,10 @@ def _patch_getaddrinfo():
             op=OP.SOCKET_DNS,
             name=_get_span_description(host, port),
             origin=SocketIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data("host", host)
-            span.set_data("port", port)
+            span.set_attribute("host", host)
+            span.set_attribute("port", port)
 
             return real_getaddrinfo(host, port, family, type, proto, flags)