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

{sentry_sdk-2.63.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.63.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.63.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.63.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.63.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.63.0 → sentry_sdk-2.65.0}/sentry_sdk/client.py

@@ -1,7 +1,9 @@
 import json
 import os
+import platform
 import random
 import socket
+import sys
 import uuid
 import warnings
 from collections.abc import Iterable, Mapping
@@ -21,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
@@ -241,6 +247,11 @@ def _serialized_v1_span_to_serialized_v2_span(
         if "version" in sdk_info:
             attributes["sentry.sdk.version"] = sdk_info["version"]
 
+    attributes["process.runtime.name"] = platform.python_implementation()
+    attributes["process.runtime.version"] = (
+        f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    )
+
     if not attributes:
         return res
 
@@ -338,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):
@@ -607,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.63.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,
     )
@@ -518,6 +520,12 @@ class SPANDATA:
     Example: postgresql
     """
 
+    DB_QUERY_TEXT = "db.query.text"
+    """
+    The database query being executed.
+    Example: "SELECT * FROM users WHERE id = $1"
+    """
+
     DB_SYSTEM_NAME = "db.system.name"
     """
     An identifier for the database management system (DBMS) product being used. See OpenTelemetry's list of well-known DBMS identifiers.
@@ -1014,6 +1022,12 @@ class SPANDATA:
     Example: "details"
     """
 
+    URL_PATH = "url.path"
+    """
+    The URI path component.
+    Example: "/foo"
+    """
+
     URL_QUERY = "url.query"
     """
     The query string present in the URL. Note that this does not contain the leading ? character, while the `http.query` attribute does.
@@ -1180,6 +1194,8 @@ class OP:
     COHERE_CHAT_COMPLETIONS_CREATE = "ai.chat_completions.create.cohere"
     COHERE_EMBEDDINGS_CREATE = "ai.embeddings.create.cohere"
     DB = "db"
+    DB_CURSOR_ITERATOR = "db.cursor.iter"
+    DB_CURSOR_FETCH = "db.cursor.fetch"
     DB_REDIS = "db.redis"
     EVENT_DJANGO = "event.django"
     FUNCTION = "function"
@@ -1320,7 +1336,7 @@ class ClientConstructor:
         before_send_metric: "Optional[Callable[[Metric, Hint], Optional[Metric]]]" = None,
         org_id: "Optional[str]" = None,
         strict_trace_continuation: bool = False,
-        stream_gen_ai_spans: bool = False,
+        stream_gen_ai_spans: bool = True,
     ) -> None:
         """Initialize the Sentry SDK with the given parameters. All parameters described here can be used in a call to `sentry_sdk.init()`.
 
@@ -1741,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
 
@@ -1765,4 +1799,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.63.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.63.0 → sentry_sdk-2.65.0}/sentry_sdk/integrations/_asgi_common.py

@@ -1,4 +1,5 @@
 import urllib
+from enum import Enum
 from typing import TYPE_CHECKING
 
 from sentry_sdk.integrations._wsgi_common import _filter_headers
@@ -12,6 +13,11 @@ if TYPE_CHECKING:
     from sentry_sdk.utils import AnnotatedValue
 
 
+class _RootPathInPath(Enum):
+    EXCLUDED = "excluded"
+    EITHER = "either"
+
+
 def _get_headers(asgi_scope: "Any") -> "Dict[str, str]":
     """
     Extract headers from the ASGI scope, in the format that the Sentry protocol expects.
@@ -28,10 +34,27 @@ def _get_headers(asgi_scope: "Any") -> "Dict[str, str]":
     return headers
 
 
+def _get_path(
+    asgi_scope: "Dict[str, Any]", root_path_in_path: "_RootPathInPath"
+) -> "str":
+    if root_path_in_path is _RootPathInPath.EXCLUDED:
+        return asgi_scope.get("root_path", "") + asgi_scope.get("path", "")
+
+    # Inverse of https://github.com/Kludex/starlette/blob/de970d7b3facb853eb7ad077decbf3d94f2aab6c/starlette/_utils.py#L96
+    path = asgi_scope["path"]
+    root_path = asgi_scope.get("root_path", "")
+
+    if not root_path or path == root_path or path.startswith(root_path + "/"):
+        return path
+
+    return root_path + path
+
+
 def _get_url(
     asgi_scope: "Dict[str, Any]",
     default_scheme: "Literal['ws', 'http']",
     host: "Optional[Union[AnnotatedValue, str]]",
+    path: str,
 ) -> str:
     """
     Extract URL from the ASGI scope, without also including the querystring.
@@ -39,7 +62,6 @@ def _get_url(
     scheme = asgi_scope.get("scheme", default_scheme)
 
     server = asgi_scope.get("server", None)
-    path = asgi_scope.get("root_path", "") + asgi_scope.get("path", "")
 
     if host:
         return "%s://%s%s" % (scheme, host, path)
@@ -81,7 +103,10 @@ def _get_ip(asgi_scope: "Any") -> str:
     return asgi_scope.get("client")[0]
 
 
-def _get_request_data(asgi_scope: "Any") -> "Dict[str, Any]":
+def _get_request_data(
+    asgi_scope: "Any",
+    root_path_in_path: "_RootPathInPath",
+) -> "Dict[str, Any]":
     """
     Returns data related to the HTTP request from the ASGI scope.
     """
@@ -96,7 +121,10 @@ def _get_request_data(asgi_scope: "Any") -> "Dict[str, Any]":
         request_data["query_string"] = _get_query(asgi_scope)
 
         request_data["url"] = _get_url(
-            asgi_scope, "http" if ty == "http" else "ws", headers.get("host")
+            asgi_scope,
+            "http" if ty == "http" else "ws",
+            headers.get("host"),
+            path=_get_path(asgi_scope=asgi_scope, root_path_in_path=root_path_in_path),
         )
 
     client = asgi_scope.get("client")
@@ -106,7 +134,10 @@ def _get_request_data(asgi_scope: "Any") -> "Dict[str, Any]":
     return request_data
 
 
-def _get_request_attributes(asgi_scope: "Any") -> "dict[str, Any]":
+def _get_request_attributes(
+    asgi_scope: "Any",
+    root_path_in_path: "_RootPathInPath",
+) -> "dict[str, Any]":
     """
     Return attributes related to the HTTP request from the ASGI scope.
     """
@@ -126,8 +157,14 @@ def _get_request_attributes(asgi_scope: "Any") -> "dict[str, Any]":
             if query:
                 attributes["http.query"] = query
 
+            path = _get_path(asgi_scope=asgi_scope, root_path_in_path=root_path_in_path)
+            attributes["url.path"] = path
+
             url_without_query_string = _get_url(
-                asgi_scope, "http" if ty == "http" else "ws", headers.get("host")
+                asgi_scope,
+                "http" if ty == "http" else "ws",
+                headers.get("host"),
+                path=path,
             )
             query_string = _get_query(asgi_scope)
             attributes["url.full"] = (