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

sentry_sdk/integrations/celery/__init__.py

@@ -4,8 +4,7 @@ from functools import wraps
 
 import sentry_sdk
 from sentry_sdk import isolation_scope
-from sentry_sdk.api import continue_trace
-from sentry_sdk.consts import OP, SPANSTATUS, SPANDATA
+from sentry_sdk.consts import OP, SPANSTATUS, SPANDATA, BAGGAGE_HEADER_NAME
 from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
 from sentry_sdk.integrations.celery.beat import (
     _patch_beat_apply_entry,
@@ -14,7 +13,7 @@ from sentry_sdk.integrations.celery.beat import (
 )
 from sentry_sdk.integrations.celery.utils import _now_seconds_since_epoch
 from sentry_sdk.integrations.logging import ignore_logger
-from sentry_sdk.tracing import BAGGAGE_HEADER_NAME, TransactionSource
+from sentry_sdk.tracing import TransactionSource
 from sentry_sdk.tracing_utils import Baggage
 from sentry_sdk.utils import (
     capture_internal_exceptions,
@@ -101,9 +100,9 @@ class CeleryIntegration(Integration):
 def _set_status(status):
     # type: (str) -> None
     with capture_internal_exceptions():
-        scope = sentry_sdk.get_current_scope()
-        if scope.span is not None:
-            scope.span.set_status(status)
+        span = sentry_sdk.get_current_span()
+        if span is not None:
+            span.set_status(status)
 
 
 def _capture_exception(task, exc_info):
@@ -113,7 +112,6 @@ def _capture_exception(task, exc_info):
         return
 
     if isinstance(exc_info[1], CELERY_CONTROL_FLOW_EXCEPTIONS):
-        # ??? Doesn't map to anything
         _set_status("aborted")
         return
 
@@ -277,6 +275,7 @@ def _wrap_task_run(f):
                 op=OP.QUEUE_SUBMIT_CELERY,
                 name=task_name,
                 origin=CeleryIntegration.origin,
+                only_if_parent=True,
             )
             if not task_started_from_beat
             else NoOpMgr()
@@ -307,40 +306,29 @@ def _wrap_tracer(task, f):
         with isolation_scope() as scope:
             scope._name = "celery"
             scope.clear_breadcrumbs()
+            scope.set_transaction_name(task.name, source=TransactionSource.TASK)
             scope.add_event_processor(_make_event_processor(task, *args, **kwargs))
 
-            transaction = None
-
             # Celery task objects are not a thing to be trusted. Even
             # something such as attribute access can fail.
-            with capture_internal_exceptions():
-                headers = args[3].get("headers") or {}
-                transaction = continue_trace(
-                    headers,
+            headers = args[3].get("headers") or {}
+
+            with sentry_sdk.continue_trace(headers):
+                with sentry_sdk.start_span(
                     op=OP.QUEUE_TASK_CELERY,
-                    name="unknown celery task",
+                    name=task.name,
                     source=TransactionSource.TASK,
                     origin=CeleryIntegration.origin,
-                )
-                transaction.name = task.name
-                transaction.set_status(SPANSTATUS.OK)
+                    # for some reason, args[1] is a list if non-empty but a
+                    # tuple if empty
+                    attributes=_prepopulate_attributes(task, list(args[1]), args[2]),
+                ) as root_span:
+                    return_value = f(*args, **kwargs)
 
-            if transaction is None:
-                return f(*args, **kwargs)
+                    if root_span.status is None:
+                        root_span.set_status(SPANSTATUS.OK)
 
-            with sentry_sdk.start_transaction(
-                transaction,
-                custom_sampling_context={
-                    "celery_job": {
-                        "task": task.name,
-                        # for some reason, args[1] is a list if non-empty but a
-                        # tuple if empty
-                        "args": list(args[1]),
-                        "kwargs": args[2],
-                    }
-                },
-            ):
-                return f(*args, **kwargs)
+                    return return_value
 
     return _inner  # type: ignore
 
@@ -355,7 +343,7 @@ def _set_messaging_destination_name(task, span):
             if delivery_info.get("exchange") == "" and routing_key is not None:
                 # Empty exchange indicates the default exchange, meaning the tasks
                 # are sent to the queue with the same name as the routing key.
-                span.set_data(SPANDATA.MESSAGING_DESTINATION_NAME, routing_key)
+                span.set_attribute(SPANDATA.MESSAGING_DESTINATION_NAME, routing_key)
 
 
 def _wrap_task_call(task, f):
@@ -377,6 +365,7 @@ def _wrap_task_call(task, f):
                 op=OP.QUEUE_PROCESS,
                 name=task.name,
                 origin=CeleryIntegration.origin,
+                only_if_parent=True,
             ) as span:
                 _set_messaging_destination_name(task, span)
 
@@ -391,23 +380,26 @@ def _wrap_task_call(task, f):
                         )
 
                 if latency is not None:
-                    span.set_data(SPANDATA.MESSAGING_MESSAGE_RECEIVE_LATENCY, latency)
+                    span.set_attribute(
+                        SPANDATA.MESSAGING_MESSAGE_RECEIVE_LATENCY, latency
+                    )
 
                 with capture_internal_exceptions():
-                    span.set_data(SPANDATA.MESSAGING_MESSAGE_ID, task.request.id)
+                    span.set_attribute(SPANDATA.MESSAGING_MESSAGE_ID, task.request.id)
 
                 with capture_internal_exceptions():
-                    span.set_data(
+                    span.set_attribute(
                         SPANDATA.MESSAGING_MESSAGE_RETRY_COUNT, task.request.retries
                     )
 
                 with capture_internal_exceptions():
-                    span.set_data(
+                    span.set_attribute(
                         SPANDATA.MESSAGING_SYSTEM,
                         task.app.connection().transport.driver_type,
                     )
 
                 return f(*args, **kwargs)
+
         except Exception:
             exc_info = sys.exc_info()
             with capture_internal_exceptions():
@@ -506,23 +498,41 @@ def _patch_producer_publish():
             op=OP.QUEUE_PUBLISH,
             name=task_name,
             origin=CeleryIntegration.origin,
+            only_if_parent=True,
         ) as span:
             if task_id is not None:
-                span.set_data(SPANDATA.MESSAGING_MESSAGE_ID, task_id)
+                span.set_attribute(SPANDATA.MESSAGING_MESSAGE_ID, task_id)
 
             if exchange == "" and routing_key is not None:
                 # Empty exchange indicates the default exchange, meaning messages are
                 # routed to the queue with the same name as the routing key.
-                span.set_data(SPANDATA.MESSAGING_DESTINATION_NAME, routing_key)
+                span.set_attribute(SPANDATA.MESSAGING_DESTINATION_NAME, routing_key)
 
             if retries is not None:
-                span.set_data(SPANDATA.MESSAGING_MESSAGE_RETRY_COUNT, retries)
+                span.set_attribute(SPANDATA.MESSAGING_MESSAGE_RETRY_COUNT, retries)
 
             with capture_internal_exceptions():
-                span.set_data(
+                span.set_attribute(
                     SPANDATA.MESSAGING_SYSTEM, self.connection.transport.driver_type
                 )
 
             return original_publish(self, *args, **kwargs)
 
     Producer.publish = sentry_publish
+
+
+def _prepopulate_attributes(task, args, kwargs):
+    # type: (Any, *Any, **Any) -> dict[str, str]
+    attributes = {
+        "celery.job.task": task.name,
+    }
+
+    for i, arg in enumerate(args):
+        with capture_internal_exceptions():
+            attributes[f"celery.job.args.{i}"] = str(arg)
+
+    for kwarg, value in kwargs.items():
+        with capture_internal_exceptions():
+            attributes[f"celery.job.kwargs.{kwarg}"] = str(value)
+
+    return attributes

sentry_sdk/integrations/clickhouse_driver.py

@@ -3,9 +3,13 @@ from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
 from sentry_sdk.tracing import Span
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.utils import capture_internal_exceptions, ensure_integration_enabled
+from sentry_sdk.utils import (
+    _serialize_span_attribute,
+    capture_internal_exceptions,
+    ensure_integration_enabled,
+)
 
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, cast, Any, Dict, TypeVar
 
 # Hack to get new Python features working in older versions
 # without introducing a hard dependency on `typing_extensions`
@@ -84,19 +88,23 @@ def _wrap_start(f: Callable[P, T]) -> Callable[P, T]:
             op=OP.DB,
             name=query,
             origin=ClickhouseDriverIntegration.origin,
+            only_if_parent=True,
         )
 
         connection._sentry_span = span  # type: ignore[attr-defined]
 
-        _set_db_data(span, connection)
-
-        span.set_data("query", query)
+        data = _get_db_data(connection)
+        data = cast("dict[str, Any]", data)
+        data["db.query.text"] = query
 
         if query_id:
-            span.set_data("db.query_id", query_id)
+            data["db.query_id"] = query_id
 
         if params and should_send_default_pii():
-            span.set_data("db.params", params)
+            data["db.params"] = params
+
+        connection._sentry_db_data = data  # type: ignore[attr-defined]
+        _set_on_span(span, data)
 
         # run the original code
         ret = f(*args, **kwargs)
@@ -109,20 +117,32 @@ def _wrap_start(f: Callable[P, T]) -> Callable[P, T]:
 def _wrap_end(f: Callable[P, T]) -> Callable[P, T]:
     def _inner_end(*args: P.args, **kwargs: P.kwargs) -> T:
         res = f(*args, **kwargs)
-        instance = args[0]
-        span = getattr(instance.connection, "_sentry_span", None)  # type: ignore[attr-defined]
+        client = cast("clickhouse_driver.client.Client", args[0])
+        connection = client.connection
 
+        span = getattr(connection, "_sentry_span", None)
         if span is not None:
+            data = getattr(connection, "_sentry_db_data", {})
+
             if res is not None and should_send_default_pii():
-                span.set_data("db.result", res)
+                data["db.result"] = res
+                span.set_attribute("db.result", _serialize_span_attribute(res))
 
             with capture_internal_exceptions():
-                span.scope.add_breadcrumb(
-                    message=span._data.pop("query"), category="query", data=span._data
-                )
+                query = data.pop("db.query.text", None)
+                if query:
+                    sentry_sdk.add_breadcrumb(
+                        message=query, category="query", data=data
+                    )
 
             span.finish()
 
+            try:
+                del connection._sentry_db_data
+                del connection._sentry_span
+            except AttributeError:
+                pass
+
         return res
 
     return _inner_end
@@ -130,28 +150,39 @@ def _wrap_end(f: Callable[P, T]) -> Callable[P, T]:
 
 def _wrap_send_data(f: Callable[P, T]) -> Callable[P, T]:
     def _inner_send_data(*args: P.args, **kwargs: P.kwargs) -> T:
-        instance = args[0]  # type: clickhouse_driver.client.Client
-        data = args[2]
-        span = getattr(instance.connection, "_sentry_span", None)
+        client = cast("clickhouse_driver.client.Client", args[0])
+        connection = client.connection
+        db_params_data = cast("list[Any]", args[2])
+        span = getattr(connection, "_sentry_span", None)
 
         if span is not None:
-            _set_db_data(span, instance.connection)
+            data = _get_db_data(connection)
+            _set_on_span(span, data)
 
             if should_send_default_pii():
-                db_params = span._data.get("db.params", [])
-                db_params.extend(data)
-                span.set_data("db.params", db_params)
+                saved_db_data = getattr(
+                    connection, "_sentry_db_data", {}
+                )  # type: dict[str, Any]
+                db_params = saved_db_data.get("db.params") or []  # type: list[Any]
+                db_params.extend(db_params_data)
+                saved_db_data["db.params"] = db_params
+                span.set_attribute("db.params", _serialize_span_attribute(db_params))
 
         return f(*args, **kwargs)
 
     return _inner_send_data
 
 
-def _set_db_data(
-    span: Span, connection: clickhouse_driver.connection.Connection
-) -> None:
-    span.set_data(SPANDATA.DB_SYSTEM, "clickhouse")
-    span.set_data(SPANDATA.SERVER_ADDRESS, connection.host)
-    span.set_data(SPANDATA.SERVER_PORT, connection.port)
-    span.set_data(SPANDATA.DB_NAME, connection.database)
-    span.set_data(SPANDATA.DB_USER, connection.user)
+def _get_db_data(connection: clickhouse_driver.connection.Connection) -> Dict[str, str]:
+    return {
+        SPANDATA.DB_SYSTEM: "clickhouse",
+        SPANDATA.SERVER_ADDRESS: connection.host,
+        SPANDATA.SERVER_PORT: connection.port,
+        SPANDATA.DB_NAME: connection.database,
+        SPANDATA.DB_USER: connection.user,
+    }
+
+
+def _set_on_span(span: Span, data: Dict[str, Any]) -> None:
+    for key, value in data.items():
+        span.set_attribute(key, _serialize_span_attribute(value))

sentry_sdk/integrations/cohere.py

@@ -147,6 +147,7 @@ def _wrap_chat(f, streaming):
             op=consts.OP.COHERE_CHAT_COMPLETIONS_CREATE,
             name="cohere.client.Chat",
             origin=CohereIntegration.origin,
+            only_if_parent=True,
         )
         span.__enter__()
         try:
@@ -233,6 +234,7 @@ def _wrap_embed(f):
             op=consts.OP.COHERE_EMBEDDINGS_CREATE,
             name="Cohere Embedding Creation",
             origin=CohereIntegration.origin,
+            only_if_parent=True,
         ) as span:
             if "texts" in kwargs and (
                 should_send_default_pii() and integration.include_prompts

sentry_sdk/integrations/django/__init__.py

@@ -1,3 +1,4 @@
+import functools
 import inspect
 import sys
 import threading
@@ -5,10 +6,9 @@ import weakref
 from importlib import import_module
 
 import sentry_sdk
-from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.consts import OP, SPANDATA, SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.scope import add_global_event_processor, should_send_default_pii
 from sentry_sdk.serializer import add_global_repr_processor
-from sentry_sdk.tracing import SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.tracing_utils import add_query_source, record_sql_queries
 from sentry_sdk.utils import (
     AnnotatedValue,
@@ -55,6 +55,7 @@ try:
 except ImportError:
     raise DidNotEnable("Django not installed")
 
+from sentry_sdk.integrations.django.caching import patch_caching
 from sentry_sdk.integrations.django.transactions import LEGACY_RESOLVER
 from sentry_sdk.integrations.django.templates import (
     get_template_frame_from_exception,
@@ -64,11 +65,6 @@ from sentry_sdk.integrations.django.middleware import patch_django_middlewares
 from sentry_sdk.integrations.django.signals_handlers import patch_signals
 from sentry_sdk.integrations.django.views import patch_views
 
-if DJANGO_VERSION[:2] > (1, 8):
-    from sentry_sdk.integrations.django.caching import patch_caching
-else:
-    patch_caching = None  # type: ignore
-
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -89,19 +85,6 @@ if TYPE_CHECKING:
     from sentry_sdk._types import Event, Hint, EventProcessor, NotImplementedType
 
 
-if DJANGO_VERSION < (1, 10):
-
-    def is_authenticated(request_user):
-        # type: (Any) -> bool
-        return request_user.is_authenticated()
-
-else:
-
-    def is_authenticated(request_user):
-        # type: (Any) -> bool
-        return request_user.is_authenticated
-
-
 TRANSACTION_STYLE_VALUES = ("function_name", "url")
 
 
@@ -131,7 +114,7 @@ class DjangoIntegration(Integration):
         transaction_style="url",  # type: str
         middleware_spans=True,  # type: bool
         signals_spans=True,  # type: bool
-        cache_spans=False,  # type: bool
+        cache_spans=True,  # type: bool
         signals_denylist=None,  # type: Optional[list[signals.Signal]]
         http_methods_to_capture=DEFAULT_HTTP_METHODS_TO_CAPTURE,  # type: tuple[str, ...]
     ):
@@ -321,6 +304,7 @@ def _patch_drf():
             else:
                 old_drf_initial = APIView.initial
 
+                @functools.wraps(old_drf_initial)
                 def sentry_patched_drf_initial(self, request, *args, **kwargs):
                     # type: (APIView, Any, *Any, **Any) -> Any
                     with capture_internal_exceptions():
@@ -413,11 +397,13 @@ def _set_transaction_name_and_source(scope, transaction_style, request):
         if hasattr(urlconf, "handler404"):
             handler = urlconf.handler404
             if isinstance(handler, str):
-                scope.transaction = handler
+                scope.set_transaction_name(handler)
             else:
-                scope.transaction = transaction_from_function(
+                name = transaction_from_function(
                     getattr(handler, "view_class", handler)
                 )
+                if isinstance(name, str):
+                    scope.set_transaction_name(name)
     except Exception:
         pass
 
@@ -471,6 +457,7 @@ def _patch_get_response():
 
     old_get_response = BaseHandler.get_response
 
+    @functools.wraps(old_get_response)
     def sentry_patched_get_response(self, request):
         # type: (Any, WSGIRequest) -> Union[HttpResponse, BaseException]
         _before_get_response(request)
@@ -594,7 +581,7 @@ def _set_user_info(request, event):
 
     user = getattr(request, "user", None)
 
-    if user is None or not is_authenticated(user):
+    if user is None or not user.is_authenticated:
         return
 
     try:
@@ -621,20 +608,11 @@ def install_sql_hook():
     except ImportError:
         from django.db.backends.util import CursorWrapper
 
-    try:
-        # django 1.6 and 1.7 compatability
-        from django.db.backends import BaseDatabaseWrapper
-    except ImportError:
-        # django 1.8 or later
-        from django.db.backends.base.base import BaseDatabaseWrapper
+    from django.db.backends.base.base import BaseDatabaseWrapper
 
-    try:
-        real_execute = CursorWrapper.execute
-        real_executemany = CursorWrapper.executemany
-        real_connect = BaseDatabaseWrapper.connect
-    except AttributeError:
-        # This won't work on Django versions < 1.6
-        return
+    real_execute = CursorWrapper.execute
+    real_executemany = CursorWrapper.executemany
+    real_connect = BaseDatabaseWrapper.connect
 
     @ensure_integration_enabled(DjangoIntegration, real_execute)
     def execute(self, sql, params=None):
@@ -650,8 +628,8 @@ def install_sql_hook():
             _set_db_data(span, self)
             result = real_execute(self, sql, params)
 
-        with capture_internal_exceptions():
-            add_query_source(span)
+            with capture_internal_exceptions():
+                add_query_source(span)
 
         return result
 
@@ -670,8 +648,8 @@ def install_sql_hook():
 
             result = real_executemany(self, sql, param_list)
 
-        with capture_internal_exceptions():
-            add_query_source(span)
+            with capture_internal_exceptions():
+                add_query_source(span)
 
         return result
 
@@ -685,6 +663,7 @@ def install_sql_hook():
             op=OP.DB,
             name="connect",
             origin=DjangoIntegration.origin_db,
+            only_if_parent=True,
         ) as span:
             _set_db_data(span, self)
             return real_connect(self)
@@ -699,7 +678,7 @@ def _set_db_data(span, cursor_or_db):
     # type: (Span, Any) -> None
     db = cursor_or_db.db if hasattr(cursor_or_db, "db") else cursor_or_db
     vendor = db.vendor
-    span.set_data(SPANDATA.DB_SYSTEM, vendor)
+    span.set_attribute(SPANDATA.DB_SYSTEM, vendor)
 
     # Some custom backends override `__getattr__`, making it look like `cursor_or_db`
     # actually has a `connection` and the `connection` has a `get_dsn_parameters`
@@ -732,16 +711,16 @@ def _set_db_data(span, cursor_or_db):
 
     db_name = connection_params.get("dbname") or connection_params.get("database")
     if db_name is not None:
-        span.set_data(SPANDATA.DB_NAME, db_name)
+        span.set_attribute(SPANDATA.DB_NAME, db_name)
 
     server_address = connection_params.get("host")
     if server_address is not None:
-        span.set_data(SPANDATA.SERVER_ADDRESS, server_address)
+        span.set_attribute(SPANDATA.SERVER_ADDRESS, server_address)
 
     server_port = connection_params.get("port")
     if server_port is not None:
-        span.set_data(SPANDATA.SERVER_PORT, str(server_port))
+        span.set_attribute(SPANDATA.SERVER_PORT, str(server_port))
 
     server_socket_address = connection_params.get("unix_socket")
     if server_socket_address is not None:
-        span.set_data(SPANDATA.SERVER_SOCKET_ADDRESS, server_socket_address)
+        span.set_attribute(SPANDATA.SERVER_SOCKET_ADDRESS, server_socket_address)

sentry_sdk/integrations/django/asgi.py

@@ -88,6 +88,7 @@ def patch_django_asgi_handler_impl(cls):
 
     old_app = cls.__call__
 
+    @functools.wraps(old_app)
     async def sentry_patched_asgi_handler(self, scope, receive, send):
         # type: (Any, Any, Any, Any) -> Any
         integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
@@ -125,6 +126,7 @@ def patch_get_response_async(cls, _before_get_response):
     # type: (Any, Any) -> None
     old_get_response_async = cls.get_response_async
 
+    @functools.wraps(old_get_response_async)
     async def sentry_patched_get_response_async(self, request):
         # type: (Any, Any) -> Union[HttpResponse, BaseException]
         _before_get_response(request)
@@ -142,6 +144,7 @@ def patch_channels_asgi_handler_impl(cls):
     if channels.__version__ < "3.0.0":
         old_app = cls.__call__
 
+        @functools.wraps(old_app)
         async def sentry_patched_asgi_handler(self, receive, send):
             # type: (Any, Any, Any) -> Any
             integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
@@ -173,8 +176,8 @@ def wrap_async_view(callback):
     async def sentry_wrapped_callback(request, *args, **kwargs):
         # type: (Any, *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:
@@ -184,6 +187,7 @@ def wrap_async_view(callback):
             op=OP.VIEW_RENDER,
             name=request.resolver_match.view_name,
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ):
             return await callback(request, *args, **kwargs)
 

sentry_sdk/integrations/django/caching.py

@@ -54,27 +54,28 @@ def _patch_cache_method(cache, method_name, address, port):
             op=op,
             name=description,
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ) as span:
             value = original_method(*args, **kwargs)
 
             with capture_internal_exceptions():
                 if address is not None:
-                    span.set_data(SPANDATA.NETWORK_PEER_ADDRESS, address)
+                    span.set_attribute(SPANDATA.NETWORK_PEER_ADDRESS, address)
 
                 if port is not None:
-                    span.set_data(SPANDATA.NETWORK_PEER_PORT, port)
+                    span.set_attribute(SPANDATA.NETWORK_PEER_PORT, port)
 
                 key = _get_safe_key(method_name, args, kwargs)
                 if key is not None:
-                    span.set_data(SPANDATA.CACHE_KEY, key)
+                    span.set_attribute(SPANDATA.CACHE_KEY, key)
 
                 item_size = None
                 if is_get_operation:
                     if value:
                         item_size = len(str(value))
-                        span.set_data(SPANDATA.CACHE_HIT, True)
+                        span.set_attribute(SPANDATA.CACHE_HIT, True)
                     else:
-                        span.set_data(SPANDATA.CACHE_HIT, False)
+                        span.set_attribute(SPANDATA.CACHE_HIT, False)
                 else:  # TODO: We don't handle `get_or_set` which we should
                     arg_count = len(args)
                     if arg_count >= 2:
@@ -85,7 +86,7 @@ def _patch_cache_method(cache, method_name, address, port):
                         item_size = len(str(args[0]))
 
                 if item_size is not None:
-                    span.set_data(SPANDATA.CACHE_ITEM_SIZE, item_size)
+                    span.set_attribute(SPANDATA.CACHE_ITEM_SIZE, item_size)
 
             return value
 
@@ -133,22 +134,10 @@ def _get_address_port(settings):
     return address, int(port) if port is not None else None
 
 
-def should_enable_cache_spans():
-    # type: () -> bool
-    from sentry_sdk.integrations.django import DjangoIntegration
-
-    client = sentry_sdk.get_client()
-    integration = client.get_integration(DjangoIntegration)
-    from django.conf import settings
-
-    return integration is not None and (
-        (client.spotlight is not None and settings.DEBUG is True)
-        or integration.cache_spans is True
-    )
-
-
 def patch_caching():
     # type: () -> None
+    from sentry_sdk.integrations.django import DjangoIntegration
+
     if not hasattr(CacheHandler, "_sentry_patched"):
         if DJANGO_VERSION < (3, 2):
             original_get_item = CacheHandler.__getitem__
@@ -158,7 +147,8 @@ def patch_caching():
                 # type: (CacheHandler, str) -> Any
                 cache = original_get_item(self, alias)
 
-                if should_enable_cache_spans():
+                integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
+                if integration is not None and integration.cache_spans:
                     from django.conf import settings
 
                     address, port = _get_address_port(
@@ -180,7 +170,8 @@ def patch_caching():
                 # type: (CacheHandler, str) -> Any
                 cache = original_create_connection(self, alias)
 
-                if should_enable_cache_spans():
+                integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
+                if integration is not None and integration.cache_spans:
                     address, port = _get_address_port(self.settings[alias or "default"])
 
                     _patch_cache(cache, address, port)

sentry_sdk/integrations/django/middleware.py

@@ -89,6 +89,7 @@ def _wrap_middleware(middleware, middleware_name):
             op=OP.MIDDLEWARE_DJANGO,
             name=description,
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         )
         middleware_span.set_tag("django.function_name", function_name)
         middleware_span.set_tag("django.middleware_name", middleware_name)