sentry-sdk 2.64.0__tar.gz → 2.65.0__tar.gz

{sentry_sdk-2.64.0/sentry_sdk.egg-info → sentry_sdk-2.65.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.64.0
+Version: 2.65.0
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors
@@ -193,6 +193,11 @@ sentry_sdk.init(
     # Set traces_sample_rate to 1.0 to capture 100%
     # of traces for performance monitoring.
     traces_sample_rate=1.0,
+
+    # To disable sending user data and HTTP request/response bodies, uncomment
+    # the line below. For more info visit:
+    # https://docs.sentry.io/platforms/python/configuration/options/#data_collection
+    # data_collection={"user_info": False, "http_bodies": []},
 )
 ```
 

{sentry_sdk-2.64.0 → sentry_sdk-2.65.0}/README.md

@@ -49,6 +49,11 @@ sentry_sdk.init(
     # Set traces_sample_rate to 1.0 to capture 100%
     # of traces for performance monitoring.
     traces_sample_rate=1.0,
+
+    # To disable sending user data and HTTP request/response bodies, uncomment
+    # the line below. For more info visit:
+    # https://docs.sentry.io/platforms/python/configuration/options/#data_collection
+    # data_collection={"user_info": False, "http_bodies": []},
 )
 ```
 

{sentry_sdk-2.64.0 → sentry_sdk-2.65.0}/pyproject.toml

@@ -67,6 +67,15 @@ typing = [
     "httpx2",
     "botocore-stubs",
     "werkzeug",
+    "mcp>=2.0.0b1",
+    "starlette>=1.3.1",
+    "python-multipart>=0.0.32",
+    "pydantic>=2.13.4",
+]
+test = [
+    "dataclasses ; python_full_version < '3.7'",
+    "pytest>=6.0.0",
+    "pytest-cov",
 ]
 
 #

{sentry_sdk-2.64.0 → sentry_sdk-2.65.0}/sentry_sdk/_types.py

@@ -141,7 +141,7 @@ if TYPE_CHECKING:
     from collections.abc import Container, MutableMapping, Sequence
     from datetime import datetime
     from types import TracebackType
-    from typing import Any, Callable, Dict, Mapping, NotRequired, Optional, Type
+    from typing import Any, Callable, Dict, List, Mapping, NotRequired, Optional, Type
 
     from typing_extensions import Literal, TypedDict
 
@@ -152,6 +152,59 @@ if TYPE_CHECKING:
         version: str
         packages: "Sequence[Mapping[str, str]]"
 
+    class KeyValueCollectionBehaviour(TypedDict):
+        mode: 'Literal["off", "denylist", "allowlist"]'
+        terms: "NotRequired[List[str]]"
+
+    class GenAICollectionUserOptions(TypedDict, total=False):
+        inputs: bool
+        outputs: bool
+
+    class GenAICollectionBehaviour(TypedDict):
+        inputs: bool
+        outputs: bool
+
+    class GraphQLCollectionUserOptions(TypedDict, total=False):
+        document: bool
+        variables: bool
+
+    class GraphQLCollectionBehaviour(TypedDict):
+        document: bool
+        variables: bool
+
+    class HttpHeadersCollectionUserOptions(TypedDict, total=False):
+        request: "KeyValueCollectionBehaviour"
+
+    class HttpHeadersCollectionBehaviour(TypedDict):
+        request: "KeyValueCollectionBehaviour"
+
+    class DataCollectionUserOptions(TypedDict, total=False):
+        user_info: bool
+        cookies: "KeyValueCollectionBehaviour"
+        http_headers: "HttpHeadersCollectionUserOptions"
+        http_bodies: "List[str]"
+        query_params: "KeyValueCollectionBehaviour"
+        graphql: "GraphQLCollectionUserOptions"
+        gen_ai: "GenAICollectionUserOptions"
+        database_query_data: bool
+        queues: bool
+        stack_frame_variables: bool
+        frame_context_lines: int
+
+    class DataCollection(TypedDict):
+        provided_by_user: bool
+        user_info: bool
+        cookies: "KeyValueCollectionBehaviour"
+        http_headers: "HttpHeadersCollectionBehaviour"
+        http_bodies: "List[str]"
+        query_params: "KeyValueCollectionBehaviour"
+        graphql: "GraphQLCollectionBehaviour"
+        gen_ai: "GenAICollectionBehaviour"
+        database_query_data: bool
+        queues: bool
+        stack_frame_variables: bool
+        frame_context_lines: int
+
     # "critical" is an alias of "fatal" recognized by Relay
     LogLevelStr = Literal["fatal", "critical", "error", "warning", "info", "debug"]
 

{sentry_sdk-2.64.0 → sentry_sdk-2.65.0}/sentry_sdk/client.py

@@ -23,6 +23,10 @@ from sentry_sdk.consts import (
     VERSION,
     ClientConstructor,
 )
+from sentry_sdk.data_collection import (
+    _map_from_send_default_pii,
+    _resolve_data_collection,
+)
 from sentry_sdk.envelope import Envelope, Item, PayloadRef
 from sentry_sdk.integrations import _DEFAULT_INTEGRATIONS, setup_integrations
 from sentry_sdk.integrations.dedupe import DedupeIntegration
@@ -345,11 +349,13 @@ def _get_options(*args: "Optional[str]", **kwargs: "Any") -> "Dict[str, Any]":
     if rv["enable_tracing"] is True and rv["traces_sample_rate"] is None:
         rv["traces_sample_rate"] = 1.0
 
+    rv["data_collection"] = _resolve_data_collection(rv)
+
     if rv["event_scrubber"] is None:
         rv["event_scrubber"] = EventScrubber(
-            send_default_pii=(
-                False if rv["send_default_pii"] is None else rv["send_default_pii"]
-            )
+            send_default_pii=False
+            if rv["send_default_pii"] is None
+            else rv["send_default_pii"]
         )
 
     if rv["socket_options"] and not isinstance(rv["socket_options"], list):
@@ -614,6 +620,19 @@ class _Client(BaseClient):
                 self.options["error_sampler"] = sample_all
                 self.options["traces_sampler"] = sample_all
                 self.options["profiles_sampler"] = sample_all
+                # data_collection was resolved in _get_options() before this
+                # spotlight override flipped send_default_pii on. Re-derive it so
+                # data_collection agrees with should_send_default_pii() in
+                # DSN-less spotlight mode (only when the user did not set
+                # data_collection explicitly).
+                if not self.options["data_collection"]["provided_by_user"]:
+                    self.options["data_collection"] = _map_from_send_default_pii(
+                        send_default_pii=True,
+                        include_local_variables=self.options["include_local_variables"]
+                        is not False,
+                        include_source_context=self.options["include_source_context"]
+                        is not False,
+                    )
 
             self.session_flusher = SessionFlusher(capture_func=_capture_envelope)
 

{sentry_sdk-2.64.0 → sentry_sdk-2.65.0}/sentry_sdk/consts.py

@@ -45,6 +45,7 @@ if TYPE_CHECKING:
     from sentry_sdk._types import (
         BreadcrumbProcessor,
         ContinuousProfilerMode,
+        DataCollectionUserOptions,
         Event,
         EventProcessor,
         Hint,
@@ -86,6 +87,7 @@ if TYPE_CHECKING:
                 Callable[[SpanJSON, Hint], Optional[SpanJSON]]
             ],
             "suppress_asgi_chained_exceptions": Optional[bool],
+            "data_collection": Optional[DataCollectionUserOptions],
         },
         total=False,
     )
@@ -1755,7 +1757,25 @@ class ClientConstructor:
         :param stream_gen_ai_spans: When set, generative AI spans are sent in a new transport format to
             reduce downstream data loss.
 
-        :param _experiments:
+        :param _experiments: Dictionary of experimental, opt-in features that are not yet stable.
+
+            ``data_collection`` (EXPERIMENTAL): structured configuration controlling what data integrations
+            collect automatically, superseding `send_default_pii`. Passing a dict under
+            `_experiments={"data_collection": {...}}` opts into the feature; omitted fields use their
+            defaults (most categories are collected, with the sensitive denylist scrubbing values).
+            When it is not set, the SDK derives behaviour from `send_default_pii` so that upgrading
+            changes nothing. Restrict collection per category (user identity, cookies, HTTP
+            headers/bodies, query params, generative AI inputs/outputs, stack frame variables, source
+            context). If `send_default_pii` is also set, `data_collection` takes precedence.
+
+            Example::
+
+                sentry_sdk.init(
+                    dsn="...",
+                    _experiments={"data_collection": {"user_info": False, "http_bodies": []}},
+                )
+
+            See https://docs.sentry.io/platforms/python/configuration/options/#data_collection for more details.
         """
         pass
 
@@ -1779,4 +1799,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.64.0"
+VERSION = "2.65.0"

sentry_sdk-2.65.0/sentry_sdk/data_collection.py

@@ -0,0 +1,261 @@
+"""
+Data Collection configuration.
+
+Implements the ``data_collection`` client option described in the Sentry SDK
+"Data Collection" spec
+(https://develop.sentry.dev/sdk/foundations/client/data-collection/).
+
+``data_collection`` supersedes the single ``send_default_pii`` boolean with a
+structured configuration that lets users enable or restrict automatically
+collected data by category (user identity, cookies, HTTP headers, query params,
+HTTP bodies, generative AI inputs/outputs, stack frame variables, source
+context).
+
+Resolution precedence (see :func:`_resolve_data_collection`):
+
+* ``data_collection`` set, ``send_default_pii`` unset -> honour ``data_collection``
+  using the spec defaults for any omitted field.
+* ``send_default_pii`` set, ``data_collection`` unset -> derive a
+  resolved ``DataCollection`` that mirrors what ``send_default_pii`` collects today.
+* neither set -> treated as ``send_default_pii=False``.
+* both set -> ``data_collection`` wins (it is the single source of truth); a
+  ``DeprecationWarning`` is emitted for ``send_default_pii``.
+"""
+
+import warnings
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from typing import Any, Dict, Literal
+
+    from sentry_sdk._types import (
+        DataCollection,
+        GenAICollectionBehaviour,
+        GraphQLCollectionBehaviour,
+        HttpHeadersCollectionBehaviour,
+        KeyValueCollectionBehaviour,
+    )
+
+# ``http_bodies`` defaults to this (collect everything the
+# platform supports); an empty list is the explicit opt-out.
+# response bodyies are not included here because we don't
+# currently capture them (as of Jul 7 2026)
+_ALL_HTTP_BODY_TYPES = [
+    "incoming_request",
+    "outgoing_request",
+]
+
+# Default number of source lines captured above and below a stack frame.
+_DEFAULT_FRAME_CONTEXT_LINES = 5
+
+# Collection modes for key-value data (cookies, headers, query params).
+# snake_case (Python-only deviation from the spec's camelCase); never
+# serialized to Sentry.
+_VALID_KEY_VALUE_COLLECTION_BEHAVIOUR_MODES = ("off", "denylist", "allowlist")
+
+# Values of keys that contain any of
+# these terms (partial, case-insensitive) are always replaced with
+# ``"[Filtered]"`` regardless of the configured collection mode.
+_SENSITIVE_DENYLIST = [
+    "auth",
+    "token",
+    "secret",
+    "password",
+    "passwd",
+    "pwd",
+    "key",
+    "jwt",
+    "bearer",
+    "sso",
+    "saml",
+    "csrf",
+    "xsrf",
+    "credentials",
+    "session",
+    "sid",
+    "identity",
+]
+
+
+def _map_from_send_default_pii(
+    *,
+    send_default_pii: bool,
+    include_local_variables: bool,
+    include_source_context: bool,
+) -> "DataCollection":
+    """
+    Build a fully-resolved ``DataCollection`` dict that mirrors the data
+    ``send_default_pii`` collects today. Used when ``data_collection`` is not
+    provided explicitly.
+    """
+    kv_mode: "Literal['denylist', 'off']" = "denylist" if send_default_pii else "off"
+    terms = [] if send_default_pii else ["forwarded", "-ip", "remote-", "via", "-user"]
+
+    return {
+        "provided_by_user": False,
+        "user_info": send_default_pii,
+        "cookies": {"mode": kv_mode, "terms": terms},
+        # Headers are collected in both PII modes today (sensitive ones filtered
+        # when PII is off), so this never maps to "off".
+        "http_headers": {
+            "request": {"mode": "denylist", "terms": terms},
+        },
+        # Bodies are collected regardless of PII today, bounded by
+        # ``max_request_body_size``.
+        "http_bodies": list(_ALL_HTTP_BODY_TYPES),
+        "query_params": {"mode": kv_mode, "terms": terms},
+        "graphql": {"document": send_default_pii, "variables": send_default_pii},
+        "gen_ai": {"inputs": send_default_pii, "outputs": send_default_pii},
+        "database_query_data": send_default_pii,
+        "queues": send_default_pii,
+        "stack_frame_variables": include_local_variables,
+        "frame_context_lines": (
+            _DEFAULT_FRAME_CONTEXT_LINES if include_source_context else 0
+        ),
+    }
+
+
+def _resolve_explicit(
+    d: "dict[str, Any]",
+    include_local_variables: bool,
+    include_source_context: bool,
+) -> "DataCollection":
+    """
+    Build a fully-resolved ``DataCollection`` from a user-supplied
+    ``data_collection`` dict, filling in spec defaults for any omitted or
+    partially-specified field. Frame fields fall back to the legacy
+    ``include_local_variables`` / ``include_source_context`` options when unset.
+    """
+    # frame_context_lines accepts an integer or a boolean fallback (spec: True
+    # -> platform default of 5, False -> 0). bool is a subclass of int, so
+    # coerce explicitly before treating it as a line count.
+    frame_context_lines = d.get("frame_context_lines")
+    if frame_context_lines is None:
+        frame_context_lines = (
+            _DEFAULT_FRAME_CONTEXT_LINES if include_source_context else 0
+        )
+    elif isinstance(frame_context_lines, bool):
+        frame_context_lines = _DEFAULT_FRAME_CONTEXT_LINES if frame_context_lines else 0
+
+    stack_frame_variables = d.get("stack_frame_variables")
+    if stack_frame_variables is None:
+        stack_frame_variables = include_local_variables
+
+    # http_bodies: omitted means "all valid types"; [] is the explicit opt-out.
+    http_bodies = d.get("http_bodies")
+    http_bodies = (
+        list(http_bodies) if http_bodies is not None else list(_ALL_HTTP_BODY_TYPES)
+    )
+
+    return {
+        "provided_by_user": True,
+        "user_info": d.get("user_info", True),
+        "cookies": _kvcb_from_value(d.get("cookies") or {}),
+        "http_headers": _http_headers_from_value(d.get("http_headers") or {}),
+        "http_bodies": http_bodies,
+        "query_params": _kvcb_from_value(d.get("query_params") or {}),
+        "graphql": _graphql_from_value(d.get("graphql") or {}),
+        "gen_ai": _gen_ai_from_value(d.get("gen_ai") or {}),
+        "database_query_data": d.get("database_query_data", True),
+        "queues": d.get("queues", True),
+        "stack_frame_variables": stack_frame_variables,
+        "frame_context_lines": frame_context_lines,
+    }
+
+
+def _kvcb_from_value(
+    val: "dict[str, Any]",
+) -> "KeyValueCollectionBehaviour":
+    mode = val.get("mode", "denylist")
+    terms = val.get("terms", None)
+
+    if mode not in _VALID_KEY_VALUE_COLLECTION_BEHAVIOUR_MODES:
+        raise ValueError(
+            "Invalid collection mode {!r}. Must be one of {}.".format(
+                mode, _VALID_KEY_VALUE_COLLECTION_BEHAVIOUR_MODES
+            )
+        )
+
+    behaviour: "dict[str, Any]" = {"mode": mode}
+    if terms is not None:
+        behaviour["terms"] = list(terms)
+    return cast("KeyValueCollectionBehaviour", behaviour)
+
+
+def _http_headers_from_value(
+    val: "dict[str, Any]",
+) -> "HttpHeadersCollectionBehaviour":
+    return {
+        "request": (
+            _kvcb_from_value(val["request"])
+            if "request" in val
+            else _kvcb_from_value({"mode": "denylist"})
+        ),
+    }
+
+
+def _gen_ai_from_value(val: "dict[str, Any]") -> "GenAICollectionBehaviour":
+    return {
+        "inputs": val.get("inputs", True),
+        "outputs": val.get("outputs", True),
+    }
+
+
+def _graphql_from_value(
+    val: "dict[str, Any]",
+) -> "GraphQLCollectionBehaviour":
+    return {
+        "document": val.get("document", True),
+        "variables": val.get("variables", True),
+    }
+
+
+def _resolve_data_collection(options: "Dict[str, Any]") -> "DataCollection":
+    """
+    Resolve the effective ``DataCollection`` dict from client ``options``.
+
+    Reads ``data_collection``, ``send_default_pii``, ``include_local_variables``
+    and ``include_source_context`` and returns a fully-resolved dict with
+    concrete values for every field.
+
+    ``data_collection`` must be a plain ``dict``.
+    """
+    user_dc = options.get("_experiments", {}).get("data_collection")
+    send_default_pii = options.get("send_default_pii")
+
+    include_local_variables = (
+        bool(options.get("include_local_variables"))
+        if options.get("include_local_variables") is not None
+        else True
+    )
+    include_source_context = (
+        bool(options.get("include_source_context"))
+        if options.get("include_source_context") is not None
+        else True
+    )
+
+    if user_dc is not None:
+        if not isinstance(user_dc, dict):
+            raise TypeError(
+                "`data_collection` must be a dict, got {!r}.".format(
+                    type(user_dc).__name__
+                )
+            )
+        if send_default_pii is not None:
+            warnings.warn(
+                "`send_default_pii` is deprecated and ignored when "
+                "`data_collection` is set.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        return _resolve_explicit(
+            user_dc,
+            include_local_variables,
+            include_source_context,
+        )
+
+    return _map_from_send_default_pii(
+        send_default_pii=bool(send_default_pii),
+        include_local_variables=include_local_variables,
+        include_source_context=include_source_context,
+    )

{sentry_sdk-2.64.0 → sentry_sdk-2.65.0}/sentry_sdk/integrations/arq.py

@@ -119,7 +119,11 @@ def patch_run_job() -> None:
                         SPANDATA.MESSAGING_MESSAGE_ID: job_id,
                     },
                     parent_span=None,
-                ):
+                ) as span:
+                    if self.queue_name is not None:
+                        span.set_attribute(
+                            SPANDATA.MESSAGING_DESTINATION_NAME, self.queue_name
+                        )
                     return await old_run_job(self, job_id, score)
 
             transaction = Transaction(
@@ -130,7 +134,9 @@ def patch_run_job() -> None:
                 origin=ArqIntegration.origin,
             )
 
-            with sentry_sdk.start_transaction(transaction):
+            with sentry_sdk.start_transaction(transaction) as span:
+                if self.queue_name is not None:
+                    span.set_data(SPANDATA.MESSAGING_DESTINATION_NAME, self.queue_name)
                 return await old_run_job(self, job_id, score)
 
     Worker.run_job = _sentry_run_job

{sentry_sdk-2.64.0 → sentry_sdk-2.65.0}/sentry_sdk/integrations/django/middleware.py

@@ -32,8 +32,9 @@ DJANGO_SUPPORTS_ASYNC_MIDDLEWARE = DJANGO_VERSION >= (3, 1)
 
 if not DJANGO_SUPPORTS_ASYNC_MIDDLEWARE:
     _asgi_middleware_mixin_factory = lambda _: object
+    iscoroutinefunction = lambda _: False
 else:
-    from .asgi import _asgi_middleware_mixin_factory
+    from .asgi import _asgi_middleware_mixin_factory, iscoroutinefunction
 
 
 def patch_django_middlewares() -> None:
@@ -104,15 +105,39 @@ def _wrap_middleware(middleware: "Any", middleware_name: str) -> "Any":
 
     def _get_wrapped_method(old_method: "F") -> "F":
         with capture_internal_exceptions():
+            # Middleware hooks (e.g. `process_view`, `process_exception`) may be
+            # `async def` when the middleware is async. A synchronous wrapper
+            # would hide the coroutine from Django's `iscoroutinefunction` check,
+            # causing Django to call the hook synchronously and never await the
+            # returned coroutine. Wrap async hooks with an async wrapper so the
+            # wrapped method continues to report as a coroutine function.
+            if iscoroutinefunction is not None and iscoroutinefunction(old_method):
 
-            def sentry_wrapped_method(*args: "Any", **kwargs: "Any") -> "Any":
-                middleware_span = _check_middleware_span(old_method)
+                async def async_sentry_wrapped_method(
+                    *args: "Any", **kwargs: "Any"
+                ) -> "Any":
+                    middleware_span = _check_middleware_span(old_method)
 
-                if middleware_span is None:
-                    return old_method(*args, **kwargs)
+                    if middleware_span is None:
+                        return await old_method(*args, **kwargs)
 
-                with middleware_span:
-                    return old_method(*args, **kwargs)
+                    with middleware_span:
+                        return await old_method(*args, **kwargs)
+
+                sentry_wrapped_method = async_sentry_wrapped_method
+
+            else:
+
+                def sync_sentry_wrapped_method(*args: "Any", **kwargs: "Any") -> "Any":
+                    middleware_span = _check_middleware_span(old_method)
+
+                    if middleware_span is None:
+                        return old_method(*args, **kwargs)
+
+                    with middleware_span:
+                        return old_method(*args, **kwargs)
+
+                sentry_wrapped_method = sync_sentry_wrapped_method
 
             try:
                 # fails for __call__ of function on Python 2 (see py2.7-django-1.11)

{sentry_sdk-2.64.0 → sentry_sdk-2.65.0}/sentry_sdk/integrations/dramatiq.py

@@ -3,7 +3,7 @@ from typing import TypeVar
 
 import sentry_sdk
 from sentry_sdk.api import continue_trace, get_baggage, get_traceparent
-from sentry_sdk.consts import OP, SPANSTATUS
+from sentry_sdk.consts import OP, SPANDATA, SPANSTATUS
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.integrations._wsgi_common import request_body_within_bounds
 from sentry_sdk.traces import SegmentSource
@@ -140,6 +140,7 @@ class SentryMiddleware(Middleware):  # type: ignore[misc]
                     "sentry.op": OP.QUEUE_TASK_DRAMATIQ,
                     "sentry.origin": DramatiqIntegration.origin,
                     "sentry.span.source": SegmentSource.TASK.value,
+                    SPANDATA.MESSAGING_DESTINATION_NAME: message.queue_name,
                 },
                 parent_span=None,
             )
@@ -160,6 +161,9 @@ class SentryMiddleware(Middleware):  # type: ignore[misc]
                 source=TransactionSource.TASK,
             )
             transaction.__enter__()
+            transaction.set_data(
+                SPANDATA.MESSAGING_DESTINATION_NAME, message.queue_name
+            )
             message._sentry_span_ctx = transaction
 
     def after_process_message(

{sentry_sdk-2.64.0 → sentry_sdk-2.65.0}/sentry_sdk/integrations/huey.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING
 
 import sentry_sdk
 from sentry_sdk.api import continue_trace, get_baggage, get_traceparent
-from sentry_sdk.consts import OP, SPANSTATUS
+from sentry_sdk.consts import OP, SPANDATA, SPANSTATUS
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.traces import SegmentSource, SpanStatus, StreamedSpan
@@ -86,6 +86,7 @@ def patch_enqueue() -> None:
                 attributes={
                     "sentry.op": OP.QUEUE_SUBMIT_HUEY,
                     "sentry.origin": HueyIntegration.origin,
+                    SPANDATA.MESSAGING_DESTINATION_NAME: self.name,
                 },
             )
         else:
@@ -94,6 +95,7 @@ def patch_enqueue() -> None:
                 name=span_name,
                 origin=HueyIntegration.origin,
             )
+            span_ctx.set_data(SPANDATA.MESSAGING_DESTINATION_NAME, self.name)
 
         no_headers_types = (PeriodicTask,) + tuple(
             t for t in [HueyGroup, HueyChord] if t is not None
@@ -211,6 +213,7 @@ def patch_execute() -> None:
                         "sentry.op": OP.QUEUE_TASK_HUEY,
                         "sentry.origin": HueyIntegration.origin,
                         "sentry.span.source": SegmentSource.TASK,
+                        SPANDATA.MESSAGING_DESTINATION_NAME: self.name,
                         "messaging.message.id": task.id,
                         "messaging.message.system": "huey",
                         "messaging.message.retry.count": (task.default_retries or 0)
@@ -228,6 +231,7 @@ def patch_execute() -> None:
                 )
                 transaction.set_status(SPANSTATUS.OK)
                 span_ctx = sentry_sdk.start_transaction(transaction)
+                span_ctx.set_data(SPANDATA.MESSAGING_DESTINATION_NAME, self.name)
 
             if not getattr(task, "_sentry_is_patched", False):
                 task.execute = _wrap_task_execute(task.execute)