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

sentry_sdk/integrations/launchdarkly.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
-import sentry_sdk
 
+from sentry_sdk.feature_flags import add_feature_flag
 from sentry_sdk.integrations import DidNotEnable, Integration
 
 try:
@@ -53,8 +53,8 @@ class LaunchDarklyHook(Hook):
     def after_evaluation(self, series_context, data, detail):
         # type: (EvaluationSeriesContext, dict[Any, Any], EvaluationDetail) -> dict[Any, Any]
         if isinstance(detail.value, bool):
-            flags = sentry_sdk.get_current_scope().flags
-            flags.set(series_context.key, detail.value)
+            add_feature_flag(series_context.key, detail.value)
+
         return data
 
     def before_evaluation(self, series_context, data):

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

@@ -24,7 +24,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",
@@ -43,7 +43,12 @@ LOGGING_TO_EVENT_LEVEL = {
 # 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.*",
+    ]
 )
 
 
@@ -355,6 +360,7 @@ class SentryLogsHandler(_BaseHandler):
         # type: (BaseClient, LogRecord) -> None
         scope = sentry_sdk.get_current_scope()
         otel_severity_number, otel_severity_text = _python_level_to_otel(record.levelno)
+        project_root = client.options["project_root"]
         attrs = {
             "sentry.origin": "auto.logger.log",
         }  # type: dict[str, str | bool | float | int]
@@ -374,7 +380,10 @@ class SentryLogsHandler(_BaseHandler):
         if record.lineno:
             attrs["code.line.number"] = record.lineno
         if record.pathname:
-            attrs["code.file.path"] = record.pathname
+            if project_root is not None and record.pathname.startswith(project_root):
+                attrs["code.file.path"] = record.pathname[len(project_root) + 1 :]
+            else:
+                attrs["code.file.path"] = record.pathname
         if record.funcName:
             attrs["code.function.name"] = record.funcName
 

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/openfeature.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
-import sentry_sdk
 
+from sentry_sdk.feature_flags import add_feature_flag
 from sentry_sdk.integrations import DidNotEnable, Integration
 
 try:
@@ -29,11 +29,9 @@ class OpenFeatureHook(Hook):
     def after(self, hook_context, details, hints):
         # type: (HookContext, FlagEvaluationDetails[bool], HookHints) -> None
         if isinstance(details.value, bool):
-            flags = sentry_sdk.get_current_scope().flags
-            flags.set(details.flag_key, details.value)
+            add_feature_flag(details.flag_key, details.value)
 
     def error(self, hook_context, exception, hints):
         # type: (HookContext, Exception, HookHints) -> None
         if isinstance(hook_context.default_value, bool):
-            flags = sentry_sdk.get_current_scope().flags
-            flags.set(hook_context.flag_key, hook_context.default_value)
+            add_feature_flag(hook_context.flag_key, hook_context.default_value)

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,24 +40,28 @@ 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():
-                set_db_data_fn(span, self)
-                _set_pipeline_data(
-                    span,
-                    is_cluster,
-                    get_command_args_fn,
-                    False if is_cluster else self.is_transaction,
-                    self._command_stack if is_cluster else 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.is_transaction,
+                    command_stack=(
+                        self._command_stack if is_cluster else self.command_stack
+                    ),
                 )
+                _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
@@ -80,6 +85,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__()
 
@@ -89,18 +95,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

sentry_sdk/integrations/redis/_sync_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
@@ -24,9 +25,9 @@ def patch_redis_pipeline(
     pipeline_cls,
     is_cluster,
     get_command_args_fn,
-    set_db_data_fn,
+    get_db_data_fn,
 ):
-    # type: (Any, bool, Any, Callable[[Span, Any], None]) -> None
+    # type: (Any, bool, Any, Callable[[Any], dict[str, Any]]) -> None
     old_execute = pipeline_cls.execute
 
     from sentry_sdk.integrations.redis import RedisIntegration
@@ -40,24 +41,26 @@ def patch_redis_pipeline(
             op=OP.DB_REDIS,
             name="redis.pipeline.execute",
             origin=SPAN_ORIGIN,
+            only_if_parent=True,
         ) as span:
             with capture_internal_exceptions():
-                set_db_data_fn(span, self)
-                _set_pipeline_data(
-                    span,
-                    is_cluster,
-                    get_command_args_fn,
-                    False if is_cluster else self.transaction,
-                    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,
                 )
+                _update_span(span, span_data, pipeline_data)
+                _create_breadcrumb("redis.pipeline.execute", span_data, pipeline_data)
 
             return old_execute(self, *args, **kwargs)
 
     pipeline_cls.execute = sentry_patched_execute
 
 
-def patch_redis_client(cls, is_cluster, set_db_data_fn):
-    # type: (Any, bool, Callable[[Span, Any], None]) -> None
+def patch_redis_client(cls, is_cluster, get_db_data_fn):
+    # type: (Any, bool, Callable[[Any], dict[str, Any]]) -> None
     """
     This function can be used to instrument custom redis client classes or
     subclasses.
@@ -85,6 +88,7 @@ def patch_redis_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__()
 
@@ -94,18 +98,24 @@ def patch_redis_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 = 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

sentry_sdk/integrations/redis/modules/caches.py

@@ -13,7 +13,6 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from sentry_sdk.integrations.redis import RedisIntegration
-    from sentry_sdk.tracing import Span
     from typing import Any, Optional
 
 
@@ -75,22 +74,24 @@ def _get_cache_span_description(redis_command, args, kwargs, integration):
     return description
 
 
-def _set_cache_data(span, redis_client, properties, return_value):
-    # type: (Span, Any, dict[str, Any], Optional[Any]) -> None
+def _get_cache_data(redis_client, properties, return_value):
+    # type: (Any, dict[str, Any], Optional[Any]) -> dict[str, Any]
+    data = {}
+
     with capture_internal_exceptions():
-        span.set_data(SPANDATA.CACHE_KEY, properties["key"])
+        data[SPANDATA.CACHE_KEY] = properties["key"]
 
         if properties["redis_command"] in GET_COMMANDS:
             if return_value is not None:
-                span.set_data(SPANDATA.CACHE_HIT, True)
+                data[SPANDATA.CACHE_HIT] = True
                 size = (
                     len(str(return_value).encode("utf-8"))
                     if not isinstance(return_value, bytes)
                     else len(return_value)
                 )
-                span.set_data(SPANDATA.CACHE_ITEM_SIZE, size)
+                data[SPANDATA.CACHE_ITEM_SIZE] = size
             else:
-                span.set_data(SPANDATA.CACHE_HIT, False)
+                data[SPANDATA.CACHE_HIT] = False
 
         elif properties["redis_command"] in SET_COMMANDS:
             if properties["value"] is not None:
@@ -99,7 +100,7 @@ def _set_cache_data(span, redis_client, properties, return_value):
                     if not isinstance(properties["value"], bytes)
                     else len(properties["value"])
                 )
-                span.set_data(SPANDATA.CACHE_ITEM_SIZE, size)
+                data[SPANDATA.CACHE_ITEM_SIZE] = size
 
         try:
             connection_params = redis_client.connection_pool.connection_kwargs
@@ -114,8 +115,10 @@ def _set_cache_data(span, redis_client, properties, return_value):
 
         host = connection_params.get("host")
         if host is not None:
-            span.set_data(SPANDATA.NETWORK_PEER_ADDRESS, host)
+            data[SPANDATA.NETWORK_PEER_ADDRESS] = host
 
         port = connection_params.get("port")
         if port is not None:
-            span.set_data(SPANDATA.NETWORK_PEER_PORT, port)
+            data[SPANDATA.NETWORK_PEER_PORT] = port
+
+    return data

sentry_sdk/integrations/redis/modules/queries.py

@@ -11,7 +11,6 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from redis import Redis
     from sentry_sdk.integrations.redis import RedisIntegration
-    from sentry_sdk.tracing import Span
     from typing import Any
 
 
@@ -43,26 +42,30 @@ def _get_db_span_description(integration, command_name, args):
     return description
 
 
-def _set_db_data_on_span(span, connection_params):
-    # type: (Span, dict[str, Any]) -> None
-    span.set_data(SPANDATA.DB_SYSTEM, "redis")
+def _get_connection_data(connection_params):
+    # type: (dict[str, Any]) -> dict[str, Any]
+    data = {
+        SPANDATA.DB_SYSTEM: "redis",
+    }
 
     db = connection_params.get("db")
     if db is not None:
-        span.set_data(SPANDATA.DB_NAME, str(db))
+        data[SPANDATA.DB_NAME] = str(db)
 
     host = connection_params.get("host")
     if host is not None:
-        span.set_data(SPANDATA.SERVER_ADDRESS, host)
+        data[SPANDATA.SERVER_ADDRESS] = host
 
     port = connection_params.get("port")
     if port is not None:
-        span.set_data(SPANDATA.SERVER_PORT, port)
+        data[SPANDATA.SERVER_PORT] = port
+
+    return data
 
 
-def _set_db_data(span, redis_instance):
-    # type: (Span, Redis[Any]) -> None
+def _get_db_data(redis_instance):
+    # type: (Redis[Any]) -> dict[str, Any]
     try:
-        _set_db_data_on_span(span, redis_instance.connection_pool.connection_kwargs)
+        return _get_connection_data(redis_instance.connection_pool.connection_kwargs)
     except AttributeError:
-        pass  # connections_kwargs may be missing in some cases
+        return {}  # connections_kwargs may be missing in some cases