sentry-sdk 2.30.0__py2.py3-none-any.whl → 3.0.0a2__py2.py3-none-any.whl

sentry_sdk/integrations/httpx.py

@@ -1,14 +1,15 @@
 import sentry_sdk
-from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.consts import OP, SPANDATA, BAGGAGE_HEADER_NAME
 from sentry_sdk.integrations import Integration, DidNotEnable
-from sentry_sdk.tracing import BAGGAGE_HEADER_NAME
 from sentry_sdk.tracing_utils import Baggage, should_propagate_trace
 from sentry_sdk.utils import (
     SENSITIVE_DATA_SUBSTITUTE,
     capture_internal_exceptions,
     ensure_integration_enabled,
+    http_client_status_to_breadcrumb_level,
     logger,
     parse_url,
+    set_thread_info_from_span,
 )
 
 from typing import TYPE_CHECKING
@@ -60,12 +61,20 @@ def _install_httpx_client():
                 parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE,
             ),
             origin=HttpxIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data(SPANDATA.HTTP_METHOD, request.method)
+            data = {
+                SPANDATA.HTTP_METHOD: request.method,
+            }
+            set_thread_info_from_span(data, span)
+
             if parsed_url is not None:
-                span.set_data("url", parsed_url.url)
-                span.set_data(SPANDATA.HTTP_QUERY, parsed_url.query)
-                span.set_data(SPANDATA.HTTP_FRAGMENT, parsed_url.fragment)
+                data["url"] = parsed_url.url
+                data[SPANDATA.HTTP_QUERY] = parsed_url.query
+                data[SPANDATA.HTTP_FRAGMENT] = parsed_url.fragment
+
+            for key, value in data.items():
+                span.set_attribute(key, value)
 
             if should_propagate_trace(sentry_sdk.get_client(), str(request.url)):
                 for (
@@ -86,7 +95,17 @@ def _install_httpx_client():
             rv = real_send(self, request, **kwargs)
 
             span.set_http_status(rv.status_code)
-            span.set_data("reason", rv.reason_phrase)
+            span.set_attribute("reason", rv.reason_phrase)
+
+            data[SPANDATA.HTTP_STATUS_CODE] = rv.status_code
+            data["reason"] = rv.reason_phrase
+
+            sentry_sdk.add_breadcrumb(
+                type="http",
+                category="httplib",
+                data=data,
+                level=http_client_status_to_breadcrumb_level(rv.status_code),
+            )
 
             return rv
 
@@ -114,12 +133,18 @@ def _install_httpx_async_client():
                 parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE,
             ),
             origin=HttpxIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data(SPANDATA.HTTP_METHOD, request.method)
+            data = {
+                SPANDATA.HTTP_METHOD: request.method,
+            }
             if parsed_url is not None:
-                span.set_data("url", parsed_url.url)
-                span.set_data(SPANDATA.HTTP_QUERY, parsed_url.query)
-                span.set_data(SPANDATA.HTTP_FRAGMENT, parsed_url.fragment)
+                data["url"] = parsed_url.url
+                data[SPANDATA.HTTP_QUERY] = parsed_url.query
+                data[SPANDATA.HTTP_FRAGMENT] = parsed_url.fragment
+
+            for key, value in data.items():
+                span.set_attribute(key, value)
 
             if should_propagate_trace(sentry_sdk.get_client(), str(request.url)):
                 for (
@@ -142,7 +167,17 @@ def _install_httpx_async_client():
             rv = await real_send(self, request, **kwargs)
 
             span.set_http_status(rv.status_code)
-            span.set_data("reason", rv.reason_phrase)
+            span.set_attribute("reason", rv.reason_phrase)
+
+            data[SPANDATA.HTTP_STATUS_CODE] = rv.status_code
+            data["reason"] = rv.reason_phrase
+
+            sentry_sdk.add_breadcrumb(
+                type="http",
+                category="httplib",
+                data=data,
+                level=http_client_status_to_breadcrumb_level(rv.status_code),
+            )
 
             return rv
 

sentry_sdk/integrations/huey.py

@@ -2,15 +2,16 @@ import sys
 from datetime import datetime
 
 import sentry_sdk
-from sentry_sdk.api import continue_trace, get_baggage, get_traceparent
-from sentry_sdk.consts import OP, SPANSTATUS
-from sentry_sdk.integrations import DidNotEnable, Integration
-from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import (
+from sentry_sdk.api import get_baggage, get_traceparent
+from sentry_sdk.consts import (
+    OP,
+    SPANSTATUS,
     BAGGAGE_HEADER_NAME,
     SENTRY_TRACE_HEADER_NAME,
     TransactionSource,
 )
+from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,
@@ -61,6 +62,7 @@ def patch_enqueue():
             op=OP.QUEUE_SUBMIT_HUEY,
             name=task.name,
             origin=HueyIntegration.origin,
+            only_if_parent=True,
         ):
             if not isinstance(task, PeriodicTask):
                 # Attach trace propagation data to task kwargs. We do
@@ -109,11 +111,13 @@ def _capture_exception(exc_info):
     # type: (ExcInfo) -> None
     scope = sentry_sdk.get_current_scope()
 
-    if exc_info[0] in HUEY_CONTROL_FLOW_EXCEPTIONS:
-        scope.transaction.set_status(SPANSTATUS.ABORTED)
-        return
+    if scope.root_span is not None:
+        if exc_info[0] in HUEY_CONTROL_FLOW_EXCEPTIONS:
+            scope.root_span.set_status(SPANSTATUS.ABORTED)
+            return
+
+        scope.root_span.set_status(SPANSTATUS.INTERNAL_ERROR)
 
-    scope.transaction.set_status(SPANSTATUS.INTERNAL_ERROR)
     event, hint = event_from_exception(
         exc_info,
         client_options=sentry_sdk.get_client().options,
@@ -135,6 +139,10 @@ def _wrap_task_execute(func):
             _capture_exception(exc_info)
             reraise(*exc_info)
 
+        root_span = sentry_sdk.get_current_scope().root_span
+        if root_span is not None:
+            root_span.set_status(SPANSTATUS.OK)
+
         return result
 
     return _sentry_execute  # type: ignore
@@ -153,22 +161,18 @@ def patch_execute():
                 scope.clear_breadcrumbs()
                 scope.add_event_processor(_make_event_processor(task))
 
-            sentry_headers = task.kwargs.pop("sentry_headers", None)
-
-            transaction = continue_trace(
-                sentry_headers or {},
-                name=task.name,
-                op=OP.QUEUE_TASK_HUEY,
-                source=TransactionSource.TASK,
-                origin=HueyIntegration.origin,
-            )
-            transaction.set_status(SPANSTATUS.OK)
-
             if not getattr(task, "_sentry_is_patched", False):
                 task.execute = _wrap_task_execute(task.execute)
                 task._sentry_is_patched = True
 
-            with sentry_sdk.start_transaction(transaction):
-                return old_execute(self, task, timestamp)
+            sentry_headers = task.kwargs.pop("sentry_headers", {})
+            with sentry_sdk.continue_trace(sentry_headers):
+                with sentry_sdk.start_span(
+                    name=task.name,
+                    op=OP.QUEUE_TASK_HUEY,
+                    source=TransactionSource.TASK,
+                    origin=HueyIntegration.origin,
+                ):
+                    return old_execute(self, task, timestamp)
 
     Huey._execute = _sentry_execute

sentry_sdk/integrations/huggingface_hub.py

@@ -77,6 +77,7 @@ def _wrap_text_generation(f):
             op=consts.OP.HUGGINGFACE_HUB_CHAT_COMPLETIONS_CREATE,
             name="Text Generation",
             origin=HuggingfaceHubIntegration.origin,
+            only_if_parent=True,
         )
         span.__enter__()
         try:

sentry_sdk/integrations/langchain.py

@@ -3,7 +3,7 @@ from functools import wraps
 
 import sentry_sdk
 from sentry_sdk.ai.monitoring import set_ai_pipeline_name, record_token_usage
-from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.consts import OP, SPANDATA, SPANSTATUS
 from sentry_sdk.ai.utils import set_data_normalized
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.tracing import Span
@@ -72,7 +72,6 @@ class LangchainIntegration(Integration):
 
 
 class WatchedSpan:
-    span = None  # type: Span
     num_completion_tokens = 0  # type: int
     num_prompt_tokens = 0  # type: int
     no_collect_tokens = False  # type: bool
@@ -123,8 +122,9 @@ class SentryLangchainCallback(BaseCallbackHandler):  # type: ignore[misc]
         span_data = self.span_map[run_id]
         if not span_data:
             return
-        sentry_sdk.capture_exception(error, span_data.span.scope)
-        span_data.span.__exit__(None, None, None)
+        sentry_sdk.capture_exception(error)
+        span_data.span.set_status(SPANSTATUS.INTERNAL_ERROR)
+        span_data.span.finish()
         del self.span_map[run_id]
 
     def _normalize_langchain_message(self, message):
@@ -136,21 +136,27 @@ class SentryLangchainCallback(BaseCallbackHandler):  # type: ignore[misc]
     def _create_span(self, run_id, parent_id, **kwargs):
         # type: (SentryLangchainCallback, UUID, Optional[Any], Any) -> WatchedSpan
 
-        watched_span = None  # type: Optional[WatchedSpan]
-        if parent_id:
-            parent_span = self.span_map.get(parent_id)  # type: Optional[WatchedSpan]
-            if parent_span:
-                watched_span = WatchedSpan(parent_span.span.start_child(**kwargs))
-                parent_span.children.append(watched_span)
-        if watched_span is None:
-            watched_span = WatchedSpan(sentry_sdk.start_span(**kwargs))
+        parent_watched_span = self.span_map.get(parent_id) if parent_id else None
+        sentry_span = sentry_sdk.start_span(
+            parent_span=parent_watched_span.span if parent_watched_span else None,
+            only_if_parent=True,
+            **kwargs,
+        )
+        watched_span = WatchedSpan(sentry_span)
+        if parent_watched_span:
+            parent_watched_span.children.append(watched_span)
 
         if kwargs.get("op", "").startswith("ai.pipeline."):
             if kwargs.get("name"):
                 set_ai_pipeline_name(kwargs.get("name"))
             watched_span.is_pipeline = True
 
-        watched_span.span.__enter__()
+        # the same run_id is reused for the pipeline it seems
+        # so we need to end the older span to avoid orphan spans
+        existing_span_data = self.span_map.get(run_id)
+        if existing_span_data is not None:
+            self._exit_span(existing_span_data, run_id)
+
         self.span_map[run_id] = watched_span
         self.gc_span_map()
         return watched_span
@@ -161,7 +167,8 @@ class SentryLangchainCallback(BaseCallbackHandler):  # type: ignore[misc]
         if span_data.is_pipeline:
             set_ai_pipeline_name(None)
 
-        span_data.span.__exit__(None, None, None)
+        span_data.span.set_status(SPANSTATUS.OK)
+        span_data.span.finish()
         del self.span_map[run_id]
 
     def on_llm_start(
@@ -222,7 +229,7 @@ class SentryLangchainCallback(BaseCallbackHandler):  # type: ignore[misc]
             if not model and "anthropic" in all_params.get("_type"):
                 model = "claude-2"
             if model:
-                span.set_data(SPANDATA.AI_MODEL_ID, model)
+                span.set_attribute(SPANDATA.AI_MODEL_ID, model)
             if should_send_default_pii() and self.include_prompts:
                 set_data_normalized(
                     span,

sentry_sdk/integrations/litestar.py

@@ -1,6 +1,6 @@
 from collections.abc import Set
 import sentry_sdk
-from sentry_sdk.consts import OP
+from sentry_sdk.consts import OP, TransactionSource, SOURCE_FOR_STYLE
 from sentry_sdk.integrations import (
     _DEFAULT_FAILED_REQUEST_STATUS_CODES,
     DidNotEnable,
@@ -9,7 +9,6 @@ from sentry_sdk.integrations import (
 from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
 from sentry_sdk.integrations.logging import ignore_logger
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import TransactionSource, SOURCE_FOR_STYLE
 from sentry_sdk.utils import (
     ensure_integration_enabled,
     event_from_exception,
@@ -153,6 +152,7 @@ def enable_span_for_middleware(middleware):
             op=OP.MIDDLEWARE_LITESTAR,
             name=middleware_name,
             origin=LitestarIntegration.origin,
+            only_if_parent=True,
         ) as middleware_span:
             middleware_span.set_tag("litestar.middleware_name", middleware_name)
 
@@ -165,6 +165,7 @@ def enable_span_for_middleware(middleware):
                     op=OP.MIDDLEWARE_LITESTAR_RECEIVE,
                     name=getattr(receive, "__qualname__", str(receive)),
                     origin=LitestarIntegration.origin,
+                    only_if_parent=True,
                 ) as span:
                     span.set_tag("litestar.middleware_name", middleware_name)
                     return await receive(*args, **kwargs)
@@ -182,6 +183,7 @@ def enable_span_for_middleware(middleware):
                     op=OP.MIDDLEWARE_LITESTAR_SEND,
                     name=getattr(send, "__qualname__", str(send)),
                     origin=LitestarIntegration.origin,
+                    only_if_parent=True,
                 ) as span:
                     span.set_tag("litestar.middleware_name", middleware_name)
                     return await send(message)

sentry_sdk/integrations/logging.py

@@ -25,7 +25,7 @@ if TYPE_CHECKING:
     from typing import Optional
 
 DEFAULT_LEVEL = logging.INFO
-DEFAULT_EVENT_LEVEL = logging.ERROR
+DEFAULT_EVENT_LEVEL = None  # None means no events are captured
 LOGGING_TO_EVENT_LEVEL = {
     logging.NOTSET: "notset",
     logging.DEBUG: "debug",
@@ -54,7 +54,12 @@ SEVERITY_TO_OTEL_SEVERITY = {
 # Note: Ignoring by logger name here is better than mucking with thread-locals.
 # We do not necessarily know whether thread-locals work 100% correctly in the user's environment.
 _IGNORED_LOGGERS = set(
-    ["sentry_sdk.errors", "urllib3.connectionpool", "urllib3.connection"]
+    [
+        "sentry_sdk.errors",
+        "urllib3.connectionpool",
+        "urllib3.connection",
+        "opentelemetry.*",
+    ]
 )
 
 

sentry_sdk/integrations/openai.py

@@ -139,6 +139,7 @@ def _new_chat_completion_common(f, *args, **kwargs):
         op=consts.OP.OPENAI_CHAT_COMPLETIONS_CREATE,
         name="Chat Completion",
         origin=OpenAIIntegration.origin,
+        only_if_parent=True,
     )
     span.__enter__()
 
@@ -324,6 +325,7 @@ def _new_embeddings_create_common(f, *args, **kwargs):
         op=consts.OP.OPENAI_EMBEDDINGS_CREATE,
         description="OpenAI Embedding Creation",
         origin=OpenAIIntegration.origin,
+        only_if_parent=True,
     ) as span:
         if "input" in kwargs and (
             should_send_default_pii() and integration.include_prompts

sentry_sdk/integrations/pymongo.py

@@ -1,12 +1,11 @@
 import copy
-import json
 
 import sentry_sdk
 from sentry_sdk.consts import SPANSTATUS, SPANDATA, OP
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.tracing import Span
-from sentry_sdk.utils import capture_internal_exceptions
+from sentry_sdk.utils import capture_internal_exceptions, _serialize_span_attribute
 
 try:
     from pymongo import monitoring
@@ -127,56 +126,50 @@ class CommandTracer(monitoring.CommandListener):
             command.pop("$clusterTime", None)
             command.pop("$signature", None)
 
-            tags = {
-                "db.name": event.database_name,
+            data = {
+                SPANDATA.DB_NAME: event.database_name,
                 SPANDATA.DB_SYSTEM: "mongodb",
                 SPANDATA.DB_OPERATION: event.command_name,
                 SPANDATA.DB_MONGODB_COLLECTION: command.get(event.command_name),
             }
 
             try:
-                tags["net.peer.name"] = event.connection_id[0]
-                tags["net.peer.port"] = str(event.connection_id[1])
+                data["net.peer.name"] = event.connection_id[0]
+                data["net.peer.port"] = str(event.connection_id[1])
             except TypeError:
                 pass
 
-            data = {"operation_ids": {}}  # type: Dict[str, Any]
-            data["operation_ids"]["operation"] = event.operation_id
-            data["operation_ids"]["request"] = event.request_id
-
-            data.update(_get_db_data(event))
-
             try:
                 lsid = command.pop("lsid")["id"]
-                data["operation_ids"]["session"] = str(lsid)
+                data["session_id"] = str(lsid)
             except KeyError:
                 pass
 
             if not should_send_default_pii():
                 command = _strip_pii(command)
 
-            query = json.dumps(command, default=str)
+            query = _serialize_span_attribute(command)
             span = sentry_sdk.start_span(
                 op=OP.DB,
                 name=query,
                 origin=PyMongoIntegration.origin,
+                only_if_parent=True,
             )
 
-            for tag, value in tags.items():
-                # set the tag for backwards-compatibility.
-                # TODO: remove the set_tag call in the next major release!
-                span.set_tag(tag, value)
-
-                span.set_data(tag, value)
-
-            for key, value in data.items():
-                span.set_data(key, value)
-
             with capture_internal_exceptions():
                 sentry_sdk.add_breadcrumb(
-                    message=query, category="query", type=OP.DB, data=tags
+                    message=query, category="query", type=OP.DB, data=data
                 )
 
+            for key, value in data.items():
+                span.set_attribute(key, value)
+
+            for key, value in _get_db_data(event).items():
+                span.set_attribute(key, value)
+
+            span.set_attribute("operation_id", event.operation_id)
+            span.set_attribute("request_id", event.request_id)
+
             self._ongoing_operations[self._operation_key(event)] = span.__enter__()
 
     def failed(self, event):

sentry_sdk/integrations/pyramid.py

@@ -4,11 +4,11 @@ import sys
 import weakref
 
 import sentry_sdk
+from sentry_sdk.consts import SOURCE_FOR_STYLE
 from sentry_sdk.integrations import Integration, DidNotEnable
 from sentry_sdk.integrations._wsgi_common import RequestExtractor
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import SOURCE_FOR_STYLE
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,

sentry_sdk/integrations/quart.py

@@ -3,11 +3,11 @@ import inspect
 from functools import wraps
 
 import sentry_sdk
+from sentry_sdk.consts import SOURCE_FOR_STYLE
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.integrations._wsgi_common import _filter_headers
 from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import SOURCE_FOR_STYLE
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,
@@ -122,8 +122,8 @@ def patch_scaffold_route():
                 def _sentry_func(*args, **kwargs):
                     # type: (*Any, **Any) -> Any
                     current_scope = sentry_sdk.get_current_scope()
-                    if current_scope.transaction is not None:
-                        current_scope.transaction.update_active_thread()
+                    if current_scope.root_span is not None:
+                        current_scope.root_span.update_active_thread()
 
                     sentry_scope = sentry_sdk.get_isolation_scope()
                     if sentry_scope.profile is not None:

sentry_sdk/integrations/ray.py

@@ -26,6 +26,8 @@ if TYPE_CHECKING:
     from typing import Any, Optional
     from sentry_sdk.utils import ExcInfo
 
+DEFAULT_TRANSACTION_NAME = "unknown Ray function"
+
 
 def _check_sentry_initialized():
     # type: () -> None
@@ -58,25 +60,28 @@ def _patch_ray_remote():
             """
             _check_sentry_initialized()
 
-            transaction = sentry_sdk.continue_trace(
-                _tracing or {},
-                op=OP.QUEUE_TASK_RAY,
-                name=qualname_from_function(f),
-                origin=RayIntegration.origin,
+            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.start_transaction(transaction) as transaction:
-                try:
-                    result = f(*f_args, **f_kwargs)
-                    transaction.set_status(SPANSTATUS.OK)
-                except Exception:
-                    transaction.set_status(SPANSTATUS.INTERNAL_ERROR)
-                    exc_info = sys.exc_info()
-                    _capture_exception(exc_info)
-                    reraise(*exc_info)
-
-                return result
+            with sentry_sdk.continue_trace(_tracing or {}):
+                with sentry_sdk.start_span(
+                    op=OP.QUEUE_TASK_RAY,
+                    name=root_span_name,
+                    origin=RayIntegration.origin,
+                    source=TransactionSource.TASK,
+                ) as root_span:
+                    try:
+                        result = 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
 
         rv = old_remote(_f, *args, *kwargs)
         old_remote_method = rv.remote
@@ -90,6 +95,7 @@ def _patch_ray_remote():
                 op=OP.QUEUE_SUBMIT_RAY,
                 name=qualname_from_function(f),
                 origin=RayIntegration.origin,
+                only_if_parent=True,
             ) as span:
                 tracing = {
                     k: v

sentry_sdk/integrations/redis/_async_common.py

@@ -3,14 +3,15 @@ from sentry_sdk.consts import OP
 from sentry_sdk.integrations.redis.consts import SPAN_ORIGIN
 from sentry_sdk.integrations.redis.modules.caches import (
     _compile_cache_span_properties,
-    _set_cache_data,
+    _get_cache_data,
 )
 from sentry_sdk.integrations.redis.modules.queries import _compile_db_span_properties
 from sentry_sdk.integrations.redis.utils import (
-    _set_client_data,
-    _set_pipeline_data,
+    _create_breadcrumb,
+    _get_client_data,
+    _get_pipeline_data,
+    _update_span,
 )
-from sentry_sdk.tracing import Span
 from sentry_sdk.utils import capture_internal_exceptions
 
 from typing import TYPE_CHECKING
@@ -23,9 +24,9 @@ if TYPE_CHECKING:
 
 
 def patch_redis_async_pipeline(
-    pipeline_cls, is_cluster, get_command_args_fn, set_db_data_fn
+    pipeline_cls, is_cluster, get_command_args_fn, get_db_data_fn
 ):
-    # type: (Union[type[Pipeline[Any]], type[ClusterPipeline[Any]]], bool, Any, Callable[[Span, Any], None]) -> None
+    # type: (Union[type[Pipeline[Any]], type[ClusterPipeline[Any]]], bool, Any, Callable[[Any], dict[str, Any]]) -> None
     old_execute = pipeline_cls.execute
 
     from sentry_sdk.integrations.redis import RedisIntegration
@@ -39,8 +40,11 @@ def patch_redis_async_pipeline(
             op=OP.DB_REDIS,
             name="redis.pipeline.execute",
             origin=SPAN_ORIGIN,
+            only_if_parent=True,
         ) as span:
             with capture_internal_exceptions():
+                span_data = get_db_data_fn(self)
+
                 try:
                     command_seq = self._execution_strategy._command_queue
                 except AttributeError:
@@ -49,22 +53,22 @@ def patch_redis_async_pipeline(
                     else:
                         command_seq = self.command_stack
 
-                set_db_data_fn(span, self)
-                _set_pipeline_data(
-                    span,
-                    is_cluster,
-                    get_command_args_fn,
-                    False if is_cluster else self.is_transaction,
-                    command_seq,
+                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_seq=command_seq,
                 )
+                _update_span(span, span_data, pipeline_data)
+                _create_breadcrumb("redis.pipeline.execute", span_data, pipeline_data)
 
             return await old_execute(self, *args, **kwargs)
 
     pipeline_cls.execute = _sentry_execute  # type: ignore
 
 
-def patch_redis_async_client(cls, is_cluster, set_db_data_fn):
-    # type: (Union[type[StrictRedis[Any]], type[RedisCluster[Any]]], bool, Callable[[Span, Any], None]) -> None
+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
     old_execute_command = cls.execute_command
 
     from sentry_sdk.integrations.redis import RedisIntegration
@@ -88,6 +92,7 @@ def patch_redis_async_client(cls, is_cluster, set_db_data_fn):
                 op=cache_properties["op"],
                 name=cache_properties["description"],
                 origin=SPAN_ORIGIN,
+                only_if_parent=True,
             )
             cache_span.__enter__()
 
@@ -97,18 +102,24 @@ def patch_redis_async_client(cls, is_cluster, set_db_data_fn):
             op=db_properties["op"],
             name=db_properties["description"],
             origin=SPAN_ORIGIN,
+            only_if_parent=True,
         )
         db_span.__enter__()
 
-        set_db_data_fn(db_span, self)
-        _set_client_data(db_span, is_cluster, name, *args)
+        db_span_data = get_db_data_fn(self)
+        db_client_span_data = _get_client_data(is_cluster, name, *args)
+        _update_span(db_span, db_span_data, db_client_span_data)
+        _create_breadcrumb(
+            db_properties["description"], db_span_data, db_client_span_data
+        )
 
         value = await old_execute_command(self, name, *args, **kwargs)
 
         db_span.__exit__(None, None, None)
 
         if cache_span:
-            _set_cache_data(cache_span, self, cache_properties, value)
+            cache_span_data = _get_cache_data(self, cache_properties, value)
+            _update_span(cache_span, cache_span_data)
             cache_span.__exit__(None, None, None)
 
         return value