sentry-sdk 2.70.0__tar.gz → 2.72.0__tar.gz

{sentry_sdk-2.70.0/sentry_sdk.egg-info → sentry_sdk-2.72.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.70.0
+Version: 2.72.0
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/pyproject.toml

@@ -81,6 +81,7 @@ typing = [
     "aiohttp>=3.14.3",
     "openai-agents>=0.22.0",
     "mistralai>=2.10.1",
+    "typesafe-sdk>=0.7.2",
 ]
 test = [
     "dataclasses ; python_full_version < '3.7'",

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/_batcher.py

@@ -20,6 +20,7 @@ class Batcher(Generic[T]):
     FLUSH_WAIT_TIME = 5.0
 
     TYPE = ""
+    CLIENT_REPORT_TYPE = ""
     CONTENT_TYPE = ""
 
     def __init__(
@@ -123,13 +124,16 @@ class Batcher(Generic[T]):
                 return None
 
             with self._lock:
-                if len(self._buffer) >= self.MAX_BEFORE_DROP:
-                    self._record_lost(item)
-                    return None
-
-                self._buffer.append(item)
-                if len(self._buffer) >= self.MAX_BEFORE_FLUSH:
-                    self._flush_event.set()
+                dropped = len(self._buffer) >= self.MAX_BEFORE_DROP
+                if not dropped:
+                    self._buffer.append(item)
+                    if len(self._buffer) >= self.MAX_BEFORE_FLUSH:
+                        self._flush_event.set()
+
+            # Record the loss outside of the lock, since this might involve
+            # serializing the item to report lost bytes
+            if dropped:
+                self._record_lost(item)
         finally:
             self._active.flag = False
 
@@ -149,25 +153,25 @@ class Batcher(Generic[T]):
         finally:
             self._active.flag = was_active
 
-    def _add_to_envelope(self, envelope: "Envelope") -> None:
-        envelope.add_item(
-            Item(
-                type=self.TYPE,
-                content_type=self.CONTENT_TYPE,
-                headers={
-                    "item_count": len(self._buffer),
-                },
-                payload=PayloadRef(
-                    json={
-                        "version": 2,
-                        "items": [
-                            self._to_transport_format(item) for item in self._buffer
-                        ],
-                    }
-                ),
-            )
+    @classmethod
+    def _to_envelope_item(cls, items: "list[T]") -> "Item":
+        return Item(
+            type=cls.TYPE,
+            content_type=cls.CONTENT_TYPE,
+            headers={
+                "item_count": len(items),
+            },
+            payload=PayloadRef(
+                json={
+                    "version": 2,
+                    "items": [cls._to_transport_format(item) for item in items],
+                }
+            ),
         )
 
+    def _add_to_envelope(self, envelope: "Envelope") -> None:
+        envelope.add_item(self._to_envelope_item(self._buffer))
+
     def _flush(self) -> "Optional[Envelope]":
         envelope = Envelope(
             headers={"sent_at": format_timestamp(datetime.now(timezone.utc))}
@@ -183,7 +187,17 @@ class Batcher(Generic[T]):
         return envelope
 
     def _record_lost(self, item: "T") -> None:
-        pass
+        envelope_item = None
+        with capture_internal_exceptions():
+            envelope_item = self._to_envelope_item([item])
+
+        if envelope_item:
+            self._record_lost_func(
+                reason="queue_overflow",
+                data_category=self.CLIENT_REPORT_TYPE,
+                item=envelope_item,
+                quantity=1,
+            )
 
     @staticmethod
     def _to_transport_format(item: "T") -> "Any":

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/_log_batcher.py

@@ -1,7 +1,6 @@
 from typing import TYPE_CHECKING
 
 from sentry_sdk._batcher import Batcher
-from sentry_sdk.envelope import Item, PayloadRef
 from sentry_sdk.utils import serialize_attribute
 
 if TYPE_CHECKING:
@@ -16,6 +15,7 @@ class LogBatcher(Batcher["Log"]):
     FLUSH_WAIT_TIME = 5.0
 
     TYPE = "log"
+    CLIENT_REPORT_TYPE = "log_item"
     CONTENT_TYPE = "application/vnd.sentry.items.log+json"
 
     @staticmethod
@@ -41,26 +41,3 @@ class LogBatcher(Batcher["Log"]):
             res["span_id"] = item["span_id"]
 
         return res
-
-    def _record_lost(self, item: "Log") -> None:
-        # Construct log envelope item without sending it to report lost bytes
-        log_item = Item(
-            type=self.TYPE,
-            content_type=self.CONTENT_TYPE,
-            headers={
-                "item_count": 1,
-            },
-            payload=PayloadRef(
-                json={
-                    "version": 2,
-                    "items": [self._to_transport_format(item)],
-                }
-            ),
-        )
-
-        self._record_lost_func(
-            reason="queue_overflow",
-            data_category="log_item",
-            item=log_item,
-            quantity=1,
-        )

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/_metrics_batcher.py

@@ -15,6 +15,7 @@ class MetricsBatcher(Batcher["Metric"]):
     FLUSH_WAIT_TIME = 5.0
 
     TYPE = "trace_metric"
+    CLIENT_REPORT_TYPE = "trace_metric"
     CONTENT_TYPE = "application/vnd.sentry.items.trace-metric+json"
 
     @staticmethod
@@ -39,10 +40,3 @@ class MetricsBatcher(Batcher["Metric"]):
             res["unit"] = item["unit"]
 
         return res
-
-    def _record_lost(self, item: "Metric") -> None:
-        self._record_lost_func(
-            reason="queue_overflow",
-            data_category="trace_metric",
-            quantity=1,
-        )

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/_types.py

@@ -425,6 +425,7 @@ if TYPE_CHECKING:
         "log_item",
         "log_byte",
         "trace_metric",
+        "trace_metric_byte",
     ]
     SessionStatus = Literal["ok", "exited", "crashed", "abnormal"]
 

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/ai/monitoring.py

@@ -192,6 +192,13 @@ def record_token_usage(
     output_tokens_reasoning: "Optional[int]" = None,
     total_tokens: "Optional[int]" = None,
 ) -> None:
+    warnings.warn(
+        "record_token_usage() is deprecated and will be removed in version 3.0 of sentry-sdk. "
+        "Use the manual span API instead, e.g. span.set_attribute() (in streaming mode) or span.set_data().",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
     # TODO: move pipeline name elsewhere
     ai_pipeline_name = get_ai_pipeline_name()
     if ai_pipeline_name:

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/client.py

@@ -56,6 +56,7 @@ from sentry_sdk.utils import (
     capture_internal_exceptions,
     current_stacktrace,
     datetime_from_isoformat,
+    deprecation_warning,
     env_to_bool,
     format_timestamp,
     get_before_send_log,
@@ -350,6 +351,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
 
+    if rv["send_default_pii"] is not None:
+        deprecation_warning(
+            "The send_default_pii option is deprecated. Use data_collection "
+            "instead. "
+            "See https://docs.sentry.io/platforms/python/data-management/data-collected/"
+        )
+
     rv["data_collection"] = _resolve_data_collection(rv)
 
     # Do not add the event scrubber if data collection is enabled as it can remove data that's
@@ -403,6 +411,21 @@ def _get_options(*args: "Optional[str]", **kwargs: "Any") -> "Dict[str, Any]":
             stacklevel=2,
         )
 
+    if has_profiling_enabled(rv):
+        warnings.warn(
+            "Transaction-based profiling is deprecated and will be removed in the next major version of the SDK. "
+            "Please use continuous profiling instead: https://docs.sentry.io/platforms/python/profiling/",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        if has_span_streaming_enabled(rv):
+            warnings.warn(
+                "Transaction-based profiling has no effect when `trace_lifecycle` is set to `stream`. "
+                "Please use continuous profiling instead: https://docs.sentry.io/platforms/python/profiling/",
+                UserWarning,
+                stacklevel=2,
+            )
+
     return rv
 
 
@@ -930,14 +953,22 @@ class _Client(BaseClient):
             and event.get("type") != "transaction"
         ):
             new_event = None
+            exception_raised_in_before_send = False
             with capture_internal_exceptions():
-                new_event = before_send(event, hint or {})
+                try:
+                    new_event = before_send(event, hint or {})
+                except Exception:
+                    exception_raised_in_before_send = True
+                    raise
             if new_event is None:
                 logger.info("before send dropped event")
                 if self.transport:
-                    self.transport.record_lost_event(
-                        "before_send", data_category="error"
+                    reason = (
+                        "callback_error"
+                        if exception_raised_in_before_send
+                        else "before_send"
                     )
+                    self.transport.record_lost_event(reason, data_category="error")
 
                 # If this is an exception, reset the DedupeIntegration. It still
                 # remembers the dropped exception as the last exception, meaning
@@ -955,17 +986,29 @@ class _Client(BaseClient):
             and event.get("type") == "transaction"
         ):
             new_event = None
+            exception_raised_in_before_send_transaction = False
             spans_before = len(cast(List[Dict[str, object]], event.get("spans", [])))
+
             with capture_internal_exceptions():
-                new_event = before_send_transaction(event, hint or {})
+                try:
+                    new_event = before_send_transaction(event, hint or {})
+                except Exception:
+                    exception_raised_in_before_send_transaction = True
+                    raise
+
             if new_event is None:
                 logger.info("before send transaction dropped event")
                 if self.transport:
+                    reason = (
+                        "callback_error"
+                        if exception_raised_in_before_send_transaction
+                        else "before_send"
+                    )
                     self.transport.record_lost_event(
-                        reason="before_send", data_category="transaction"
+                        reason=reason, data_category="transaction"
                     )
                     self.transport.record_lost_event(
-                        reason="before_send",
+                        reason=reason,
                         data_category="span",
                         quantity=spans_before + 1,  # +1 for the transaction itself
                     )
@@ -1225,6 +1268,27 @@ class _Client(BaseClient):
 
         return return_value
 
+    def _record_lost_telemetry(
+        self, reason: str, ty: str, telemetry: "Union[Log, Metric]"
+    ) -> None:
+        if self.transport is None:
+            return
+
+        batcher_cls: "Union[type[LogBatcher], type[MetricsBatcher]]"
+        if ty == "log":
+            data_category: "EventDataCategory" = "log_item"
+            batcher_cls = LogBatcher
+        else:
+            data_category = "trace_metric"
+            batcher_cls = MetricsBatcher
+
+        # Construct envelope item without sending it to report lost bytes
+        item = None
+        with capture_internal_exceptions():
+            item = batcher_cls._to_envelope_item([telemetry])  # type: ignore[list-item]
+
+        self.transport.record_lost_event(reason, data_category=data_category, item=item)
+
     def _capture_telemetry(
         self,
         telemetry: "Optional[Union[Log, Metric, StreamedSpan]]",
@@ -1266,14 +1330,11 @@ class _Client(BaseClient):
                     raise
 
             if ty in ("log", "metric"):
-                # We are ok with dropping metrics and logs when an exception is raised
-                # because we allow users to drop them in their respect before_send_*
-                # functions.
                 if exception_raised_in_before_send_func:
+                    self._record_lost_telemetry("callback_error", ty, telemetry)  # type: ignore[arg-type]
                     return
-                # Logs and metrics can be dropped in their respective
-                # before_send, so if we get None, don't queue them for sending.
                 if serialized is None:
+                    self._record_lost_telemetry("before_send", ty, telemetry)  # type: ignore[arg-type]
                     return
 
             elif ty == "span" and isinstance(telemetry, StreamedSpan):

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/consts.py

@@ -390,6 +390,18 @@ class SPANDATA:
     Example: ["Token limit exceeded"]
     """
 
+    AWS_EXTENDED_REQUEST_ID = "aws.extended_request_id"
+    """
+    The AWS extended request ID as returned in the response headers.
+    Example: "wzHcyEWfmOGDIE5QOhTAqFDoDWP3y8IUvpNINCwL9N4TEHbUw0/gZJ+VZTmCNCWR7fezEN3eCiQ="
+    """
+
+    AWS_REQUEST_ID = "aws.request_id"
+    """
+    The AWS request ID as returned in the response headers.
+    Example: "79b9da39-b7ae-508a-a6bc-864b2829c622"
+    """
+
     CACHE_HIT = "cache.hit"
     """
     A boolean indicating whether the requested data was found in the cache.
@@ -414,6 +426,12 @@ class SPANDATA:
     Example: "10.1.2.80"
     """
 
+    CLOUD_REGION = "cloud.region"
+    """
+    The geographical region the resource is running.
+    Example: "us-east-1"
+    """
+
     CODE_FILEPATH = "code.filepath"
     """
     .. deprecated::
@@ -541,6 +559,12 @@ class SPANDATA:
     Example: my_user
     """
 
+    ERROR_TYPE = "error.type"
+    """
+    Describes a class of error the operation ended with.
+    Example: "timeout"
+    """
+
     GEN_AI_AGENT_NAME = "gen_ai.agent.name"
     """
     The name of the agent being used.
@@ -880,6 +904,12 @@ class SPANDATA:
     Example: GET
     """
 
+    HTTP_REQUEST_RESEND_COUNT = "http.request.resend_count"
+    """
+    The ordinal number of request resending attempt (for any reason, including redirects).
+    Example: 2
+    """
+
     HTTP_ROUTE = "http.route"
     """
     The matched route, that is, the path template used to match the request.
@@ -977,12 +1007,24 @@ class SPANDATA:
     Example: "com.example.ExampleService/exampleMethod"
     """
 
+    RPC_SERVICE = "rpc.service"
+    """
+    The full (logical) name of the service being called, including its package name, if applicable.
+    Example: "myService.BestService"
+    """
+
     RPC_RESPONSE_STATUS_CODE = "rpc.response.status_code"
     """
     Status code of the RPC returned by the RPC server or generated by the client.
     Example: "DEADLINE_EXCEEDED"
     """
 
+    RPC_SYSTEM_NAME = "rpc.system.name"
+    """
+    A string identifying the remoting system.
+    Example: "aws-api"
+    """
+
     SERVER_ADDRESS = "server.address"
     """
     Name of the database host.
@@ -1164,6 +1206,32 @@ class SPANDATA:
     Example: "prod"
     """
 
+    SENTRY_IS_LOCALHOST = "sentry.is_localhost"
+    """
+    Indicates whether a telemetry item was sent on a host, device or browser on
+    a localhost URL or IP address.
+
+    Used in inbound filters.
+    """
+
+    SENTRY_KIND = "sentry.kind"
+    """
+    Used to clarify the relationship between parents and children, or to distinguish between spans, e.g. a `server` and `client` span with the same name.
+    Example: "client", "server", "producer", "consumer", "internal"
+    """
+
+    SENTRY_OP = "sentry.op"
+    """
+    The operation of a span.
+    Example: "http.client"
+    """
+
+    SENTRY_ORIGIN = "sentry.origin"
+    """
+    The origin of the instrumentation (e.g. span, log, etc.)
+    Example: "auto.http.otel.fastify"
+    """
+
     SENTRY_RELEASE = "sentry.release"
     """
     The Sentry release.
@@ -1194,6 +1262,13 @@ class SPANDATA:
     Example: ["AtexitIntegration", "StdlibIntegration"]
     """
 
+    USER_AGENT_ORIGINAL = "user_agent.original"
+    """
+    Value of the HTTP User-Agent header sent by the client.
+
+    Used in inbound filters.
+    """
+
 
 class SPANSTATUS:
     """
@@ -1238,6 +1313,7 @@ class OP:
     GEN_AI_CHAT = "gen_ai.chat"
     GEN_AI_CREATE_AGENT = "gen_ai.create_agent"
     GEN_AI_EMBEDDINGS = "gen_ai.embeddings"
+    GEN_AI_EVALUATE = "gen_ai.evaluate"
     GEN_AI_EXECUTE_TOOL = "gen_ai.execute_tool"
     GEN_AI_TEXT_COMPLETION = "gen_ai.text_completion"
     GEN_AI_HANDOFF = "gen_ai.handoff"
@@ -1848,4 +1924,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.70.0"
+VERSION = "2.72.0"

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/crons/api.py

@@ -42,7 +42,7 @@ def capture_checkin(
     status: "Optional[str]" = None,
     duration: "Optional[float]" = None,
     monitor_config: "Optional[MonitorConfig]" = None,
-) -> str:
+) -> "Optional[str]":
     check_in_event = _create_check_in_event(
         monitor_slug=monitor_slug,
         check_in_id=check_in_id,
@@ -51,7 +51,8 @@ def capture_checkin(
         monitor_config=monitor_config,
     )
 
-    sentry_sdk.capture_event(check_in_event)
+    if sentry_sdk.capture_event(check_in_event) is None:
+        return None
 
     logger.debug(
         f"[Crons] Captured check-in ({check_in_event.get('check_in_id')}): {check_in_event.get('monitor_slug')} -> {check_in_event.get('status')}"

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/integrations/__init__.py

@@ -168,6 +168,7 @@ _MIN_VERSIONS = {
     "strawberry": (0, 209, 5),
     "tornado": (6, 0),
     "typer": (0, 15),
+    "typesafe": (0, 7),
     "unleash": (6, 0, 1),
 }
 

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/integrations/_asgi_common.py

@@ -88,7 +88,7 @@ def _get_query(asgi_scope: "Any") -> "Optional[str]":
     return urllib.parse.unquote(qs.decode("latin-1"))
 
 
-def _get_ip(asgi_scope: "Any") -> str:
+def _get_ip(asgi_scope: "Any") -> "Optional[str]":
     """
     Extract IP Address from the ASGI scope based on request headers with fallback to scope client.
     """
@@ -103,7 +103,10 @@ def _get_ip(asgi_scope: "Any") -> str:
     except KeyError:
         pass
 
-    return asgi_scope.get("client")[0]
+    if asgi_scope.get("client"):
+        return asgi_scope["client"][0]
+
+    return None
 
 
 def _get_request_data(

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/integrations/aiohttp.py

@@ -46,6 +46,7 @@ from sentry_sdk.utils import (
     AnnotatedValue,
     _get_aws_sigv4_signed_headers_from_authorization_header,
     _get_aws_sigv4_signed_headers_from_url_query_string,
+    _is_localhost,
     _register_control_flow_exception,
     capture_internal_exceptions,
     ensure_integration_enabled,
@@ -146,6 +147,21 @@ class AioHttpIntegration(Integration):
                     scope.clear_breadcrumbs()
                     scope.add_event_processor(_make_request_processor(weak_request))
 
+                    scope.set_attribute(
+                        SPANDATA.SENTRY_IS_LOCALHOST,
+                        _is_localhost(
+                            client_ip=_get_client_ip(request),
+                            host_header=request.headers.get("Host"),
+                            forwarded_host_header=request.headers.get(
+                                "X-Forwarded-Host"
+                            ),
+                        ),
+                    )
+
+                    user_agent = request.headers.get("User-Agent")
+                    if user_agent:
+                        scope.set_attribute(SPANDATA.USER_AGENT_ORIGINAL, user_agent)
+
                     headers = dict(request.headers)
 
                     span_ctx: "ContextManager[Union[Span, StreamedSpan]]"
@@ -643,6 +659,17 @@ def _make_request_processor(
     return aiohttp_processor
 
 
+def _get_client_ip(request: "Request") -> "Optional[str]":
+    x_forwarded_for = request.headers.get("X-Forwarded-For", "").split(",")[0].strip()
+    if x_forwarded_for:
+        return x_forwarded_for
+
+    if request.headers.get("X-Real-IP"):
+        return request.headers["X-Real-IP"]
+
+    return request.remote
+
+
 def _capture_exception() -> "ExcInfo":
     exc_info = sys.exc_info()
     event, hint = event_from_exception(

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/integrations/anthropic.py

@@ -5,7 +5,6 @@ from functools import wraps
 from typing import TYPE_CHECKING, cast
 
 import sentry_sdk
-from sentry_sdk.ai.monitoring import record_token_usage
 from sentry_sdk.ai.utils import (
     GEN_AI_ALLOWED_MESSAGE_ROLES,
     get_start_span_function,
@@ -714,13 +713,23 @@ def _set_output_data(
                 span, SPANDATA.GEN_AI_RESPONSE_TEXT, output_messages["response"]
             )
 
-    record_token_usage(
-        span,
-        input_tokens=input_tokens,
-        output_tokens=output_tokens,
-        input_tokens_cached=cache_read_input_tokens,
-        input_tokens_cache_write=cache_write_input_tokens,
-    )
+    if input_tokens is not None:
+        set_on_span(SPANDATA.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
+
+    if cache_read_input_tokens is not None:
+        set_on_span(SPANDATA.GEN_AI_USAGE_INPUT_TOKENS_CACHED, cache_read_input_tokens)
+
+    if cache_write_input_tokens is not None:
+        set_on_span(
+            SPANDATA.GEN_AI_USAGE_INPUT_TOKENS_CACHE_WRITE,
+            cache_write_input_tokens,
+        )
+
+    if output_tokens is not None:
+        set_on_span(SPANDATA.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
+
+    if input_tokens is not None and output_tokens is not None:
+        set_on_span(SPANDATA.GEN_AI_USAGE_TOTAL_TOKENS, input_tokens + output_tokens)
 
 
 def _sentry_patched_create_sync(f: "Any", *args: "Any", **kwargs: "Any") -> "Any":

{sentry_sdk-2.70.0 → sentry_sdk-2.72.0}/sentry_sdk/integrations/asgi.py

@@ -45,6 +45,7 @@ from sentry_sdk.utils import (
     HAS_REAL_CONTEXTVARS,
     ContextVar,
     _get_installed_modules,
+    _is_localhost,
     capture_internal_exceptions,
     event_from_exception,
     has_data_collection_enabled,
@@ -232,6 +233,24 @@ class SentryAsgiMiddleware:
                     processor = partial(self.event_processor, asgi_scope=scope)
                     sentry_scope.add_event_processor(processor)
 
+                    headers = _get_headers(scope)
+                    sentry_scope.set_attribute(
+                        SPANDATA.SENTRY_IS_LOCALHOST,
+                        _is_localhost(
+                            client_ip=_get_ip(scope),
+                            url_host=scope.get("server")[0]
+                            if scope.get("server") and not headers.get("host")
+                            else None,
+                            host_header=headers.get("host"),
+                            forwarded_host_header=headers.get("x-forwarded-host"),
+                        ),
+                    )
+
+                    if headers.get("user-agent"):
+                        sentry_scope.set_attribute(
+                            SPANDATA.USER_AGENT_ORIGINAL, headers["user-agent"]
+                        )
+
                     ty = scope["type"]
                     (
                         transaction_name,
@@ -254,17 +273,16 @@ class SentryAsgiMiddleware:
                             "network.protocol.name": ty,
                         }
 
-                        if scope.get("client"):
+                        ip = _get_ip(scope)
+                        if ip:
                             client_options = sentry_sdk.get_client().options
                             if has_data_collection_enabled(client_options):
                                 if client_options["data_collection"]["user_info"]:
                                     sentry_scope.set_attribute(
-                                        SPANDATA.USER_IP_ADDRESS, _get_ip(scope)
+                                        SPANDATA.USER_IP_ADDRESS, ip
                                     )
                             elif should_send_default_pii():
-                                sentry_scope.set_attribute(
-                                    SPANDATA.USER_IP_ADDRESS, _get_ip(scope)
-                                )
+                                sentry_scope.set_attribute(SPANDATA.USER_IP_ADDRESS, ip)
 
                         if ty in ("http", "websocket"):
                             if (