Merge remote-tracking branch 'origin/master' into chore/migrate-to-tox-uv

Author: sl0thentr0py

scripts/populate_tox/config.py

@@ -392,7 +392,7 @@
         "deps": {
             # https://github.com/jamesls/fakeredis/issues/245
             # https://github.com/cunla/fakeredis-py/issues/341
-            "*": ["fakeredis<2.28.0"],
+            "*": ["fakeredis"],
             "<0.9": ["fakeredis<1.0", "redis<3.2.2"],
             ">=0.9,<0.14": ["fakeredis>=1.0,<1.7.4"],
             "py3.6,py3.7": ["fakeredis!=2.26.0"],

scripts/populate_tox/package_dependencies.jsonl

@@ -133,6 +133,5 @@ def _get_request_attributes(asgi_scope: "Any") -> "dict[str, Any]":
     if client and should_send_default_pii():
         ip = _get_ip(asgi_scope)
         attributes["client.address"] = ip
-        attributes["user.ip_address"] = ip
 
     return attributes

scripts/populate_tox/releases.jsonl

@@ -165,14 +165,12 @@ async def sentry_app_handle(
                             else {}
                         )
 
-                        client_address_attributes = (
-                            {
-                                "client.address": request.remote,
-                                "user.ip_address": request.remote,
-                            }
-                            if should_send_default_pii() and request.remote
-                            else {}
-                        )
+                        client_address_attributes = {}
+                        if should_send_default_pii() and request.remote:
+                            client_address_attributes["client.address"] = request.remote
+                            scope.set_attribute(
+                                SPANDATA.USER_IP_ADDRESS, request.remote
+                            )
 
                         span_ctx = sentry_sdk.traces.start_span(
                             # If this name makes it to the UI, AIOHTTP's URL

sentry_sdk/integrations/_asgi_common.py

@@ -12,9 +12,10 @@
 
 import sentry_sdk
 from sentry_sdk.api import continue_trace
-from sentry_sdk.consts import OP
+from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations._asgi_common import (
     _get_headers,
+    _get_ip,
     _get_request_attributes,
     _get_request_data,
     _get_url,
@@ -23,7 +24,7 @@
     DEFAULT_HTTP_METHODS_TO_CAPTURE,
     nullcontext,
 )
-from sentry_sdk.scope import Scope
+from sentry_sdk.scope import Scope, should_send_default_pii
 from sentry_sdk.sessions import track_session
 from sentry_sdk.traces import (
     SOURCE_FOR_STYLE as SEGMENT_SOURCE_FOR_STYLE,
@@ -247,6 +248,11 @@ async def _run_app(
                             "network.protocol.name": ty,
                         }
 
+                        if scope.get("client") and should_send_default_pii():
+                            sentry_scope.set_attribute(
+                                SPANDATA.USER_IP_ADDRESS, _get_ip(scope)
+                            )
+
                         if ty in ("http", "websocket"):
                             if (
                                 ty == "websocket"

sentry_sdk/integrations/aiohttp.py

@@ -14,6 +14,10 @@
 from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.tracing_utils import (
+    has_span_streaming_enabled,
+    should_truncate_gen_ai_input,
+)
 from sentry_sdk.utils import event_from_exception
 
 if TYPE_CHECKING:
@@ -68,7 +72,8 @@ def _convert_message_parts(messages: "List[Dict[str, Any]]") -> "List[Dict[str,
 
 def _input_callback(kwargs: "Dict[str, Any]") -> None:
     """Handle the start of a request."""
-    integration = sentry_sdk.get_client().get_integration(LiteLLMIntegration)
+    client = sentry_sdk.get_client()
+    integration = client.get_integration(LiteLLMIntegration)
 
     if integration is None:
         return
@@ -88,16 +93,29 @@ def _input_callback(kwargs: "Dict[str, Any]") -> None:
         operation = "chat"
 
     # Start a new span/transaction
-    span = get_start_span_function()(
-        op=(
-            consts.OP.GEN_AI_CHAT
-            if operation == "chat"
-            else consts.OP.GEN_AI_EMBEDDINGS
-        ),
-        name=f"{operation} {model}",
-        origin=LiteLLMIntegration.origin,
-    )
-    span.__enter__()
+    if has_span_streaming_enabled(client.options):
+        span = sentry_sdk.traces.start_span(
+            name=f"{operation} {model}",
+            attributes={
+                "sentry.op": (
+                    consts.OP.GEN_AI_CHAT
+                    if operation == "chat"
+                    else consts.OP.GEN_AI_EMBEDDINGS
+                ),
+                "sentry.origin": LiteLLMIntegration.origin,
+            },
+        )
+    else:
+        span = get_start_span_function()(
+            op=(
+                consts.OP.GEN_AI_CHAT
+                if operation == "chat"
+                else consts.OP.GEN_AI_EMBEDDINGS
+            ),
+            name=f"{operation} {model}",
+            origin=LiteLLMIntegration.origin,
+        )
+        span.__enter__()
 
     # Store span for later
     _get_metadata_dict(kwargs)["_sentry_span"] = span
@@ -121,9 +139,9 @@ def _input_callback(kwargs: "Dict[str, Any]") -> None:
                 )
                 client = sentry_sdk.get_client()
                 messages_data = (
-                    input_list
-                    if client.options.get("stream_gen_ai_spans", False)
-                    else truncate_and_annotate_embedding_inputs(input_list, span, scope)
+                    truncate_and_annotate_embedding_inputs(input_list, span, scope)
+                    if should_truncate_gen_ai_input(client.options)
+                    else input_list
                 )
                 if messages_data is not None:
                     set_data_normalized(
@@ -140,9 +158,9 @@ def _input_callback(kwargs: "Dict[str, Any]") -> None:
                 scope = sentry_sdk.get_current_scope()
                 messages = _convert_message_parts(messages)
                 messages_data = (
-                    messages
-                    if client.options.get("stream_gen_ai_spans", False)
-                    else truncate_and_annotate_messages(messages, span, scope)
+                    truncate_and_annotate_messages(messages, span, scope)
+                    if should_truncate_gen_ai_input(client.options)
+                    else messages
                 )
                 if messages_data is not None:
                     set_data_normalized(

sentry_sdk/integrations/asgi.py

@@ -32,12 +32,14 @@
 
 import json
 from enum import Enum, auto
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable, Dict, Optional, Union
 
 import sentry_sdk
 from sentry_sdk.integrations import Integration
 from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.traces import StreamedSpan
 from sentry_sdk.tracing import Span as SentrySpan
+from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import SENSITIVE_DATA_SUBSTITUTE
 
 
@@ -182,7 +184,9 @@ def on_event(self, event: str, sentry_span: "SentrySpan") -> None:
         elif event_type == EventTypeMapping.Event:
             process_event(deserialized_event)
 
-    def on_new_span(self, attrs: str, span_id: str) -> "Optional[SentrySpan]":
+    def on_new_span(
+        self, attrs: str, span_id: str
+    ) -> "Optional[Union[SentrySpan, StreamedSpan]]":
         attrs = json.loads(attrs)
         metadata = attrs.get("metadata", {})
 
@@ -202,13 +206,29 @@ def on_new_span(self, attrs: str, span_id: str) -> "Optional[SentrySpan]":
         else:
             sentry_span_name = "<unknown>"
 
-        kwargs = {
-            "op": "function",
-            "name": sentry_span_name,
-            "origin": self.origin,
-        }
-
-        sentry_span = sentry_sdk.start_span(**kwargs)
+        span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
+        if span_streaming:
+            sentry_span = sentry_sdk.traces.start_span(
+                name=sentry_span_name,
+                attributes={
+                    "sentry.op": "function",
+                    "sentry.origin": self.origin,
+                },
+            )
+            fields = metadata.get("fields", [])
+            for field in fields:
+                if self._include_tracing_fields():
+                    sentry_span.set_attribute(field, attrs.get(field))
+                else:
+                    sentry_span.set_attribute(field, SENSITIVE_DATA_SUBSTITUTE)
+
+            return sentry_span
+
+        sentry_span = sentry_sdk.start_span(
+            op="function",
+            name=sentry_span_name,
+            origin=self.origin,
+        )
         fields = metadata.get("fields", [])
         for field in fields:
             if self._include_tracing_fields():
@@ -225,16 +245,24 @@ def on_close(self, span_id: str, sentry_span: "SentrySpan") -> None:
 
         sentry_span.__exit__(None, None, None)
 
-    def on_record(self, span_id: str, values: str, sentry_span: "SentrySpan") -> None:
+    def on_record(
+        self, span_id: str, values: str, sentry_span: "Union[SentrySpan, StreamedSpan]"
+    ) -> None:
         if sentry_span is None:
             return
 
+        set_on_span = (
+            sentry_span.set_attribute
+            if isinstance(sentry_span, StreamedSpan)
+            else sentry_span.set_data
+        )
+
         deserialized_values = json.loads(values)
         for key, value in deserialized_values.items():
             if self._include_tracing_fields():
-                sentry_span.set_data(key, value)
+                set_on_span(key, value)
             else:
-                sentry_span.set_data(key, SENSITIVE_DATA_SUBSTITUTE)
+                set_on_span(key, SENSITIVE_DATA_SUBSTITUTE)
 
 
 class RustTracingIntegration(Integration):

sentry_sdk/integrations/litellm.py

@@ -181,6 +181,9 @@ async def _context_enter(request: "Request") -> None:
         sentry_sdk.traces.continue_trace(dict(request.headers))
         scope.set_custom_sampling_context({"sanic_request": request})
 
+        if should_send_default_pii() and request.remote_addr:
+            scope.set_attribute(SPANDATA.USER_IP_ADDRESS, request.remote_addr)
+
         span = sentry_sdk.traces.start_span(
             # Unless the request results in a 404 error, the name and source
             # will get overwritten in _set_transaction
@@ -375,7 +378,6 @@ def _get_request_attributes(request: "Request") -> "Dict[str, Any]":
 
     if should_send_default_pii() and request.remote_addr:
         attributes[SPANDATA.CLIENT_ADDRESS] = request.remote_addr
-        attributes[SPANDATA.USER_IP_ADDRESS] = request.remote_addr
 
     return attributes
 

sentry_sdk/integrations/rust_tracing.py

@@ -130,6 +130,9 @@ def _handle_request_impl(self: "RequestHandler") -> "Generator[None, None, None]
             sentry_sdk.traces.continue_trace(dict(headers))
             scope.set_custom_sampling_context({"tornado_request": self.request})
 
+            if should_send_default_pii() and self.request.remote_ip:
+                scope.set_attribute(SPANDATA.USER_IP_ADDRESS, self.request.remote_ip)
+
             span_ctx = sentry_sdk.traces.start_span(
                 name=_DEFAULT_ROOT_SPAN_NAME,
                 attributes={
@@ -204,7 +207,6 @@ def _get_request_attributes(request: "Any") -> "Dict[str, Any]":
 
     if should_send_default_pii() and request.remote_ip:
         attributes[SPANDATA.CLIENT_ADDRESS] = request.remote_ip
-        attributes[SPANDATA.USER_IP_ADDRESS] = request.remote_ip
 
     with capture_internal_exceptions():
         raw_data = _get_tornado_request_data(request)