Merge branch 'master' into constantinius/fix/integrations/pydantic-ai-report-image-inputs

Author: constantinius

.github/workflows/changelog-preview.yml

@@ -7,6 +7,7 @@ on:
     - reopened
     - edited
     - labeled
+    - unlabeled
 permissions:
   contents: write
   pull-requests: write

sentry_sdk/_types.py

@@ -217,9 +217,18 @@ class SDKInfo(TypedDict):
     Hint = Dict[str, Any]
 
     AttributeValue = (
-        str | bool | float | int
-        # TODO: relay support coming soon for
-        # | list[str] | list[bool] | list[float] | list[int]
+        str
+        | bool
+        | float
+        | int
+        | list[str]
+        | list[bool]
+        | list[float]
+        | list[int]
+        | tuple[str, ...]
+        | tuple[bool, ...]
+        | tuple[float, ...]
+        | tuple[int, ...]
     )
     Attributes = dict[str, AttributeValue]
 
@@ -232,11 +241,10 @@ class SDKInfo(TypedDict):
                 "boolean",
                 "double",
                 "integer",
-                # TODO: relay support coming soon for:
-                # "string[]",
-                # "boolean[]",
-                # "double[]",
-                # "integer[]",
+                "string[]",
+                "boolean[]",
+                "double[]",
+                "integer[]",
             ],
             "value": AttributeValue,
         },

sentry_sdk/integrations/anthropic.py

@@ -11,6 +11,7 @@
     normalize_message_roles,
     truncate_and_annotate_messages,
     get_start_span_function,
+    transform_anthropic_content_part,
 )
 from sentry_sdk.consts import OP, SPANDATA, SPANSTATUS
 from sentry_sdk.integrations import _check_minimum_version, DidNotEnable, Integration
@@ -122,6 +123,27 @@ def _collect_ai_data(
     return model, input_tokens, output_tokens, content_blocks
 
 
+def _transform_anthropic_content_block(
+    content_block: "dict[str, Any]",
+) -> "dict[str, Any]":
+    """
+    Transform an Anthropic content block using the Anthropic-specific transformer,
+    with special handling for Anthropic's text-type documents.
+    """
+    # Handle Anthropic's text-type documents specially (not covered by shared function)
+    if content_block.get("type") == "document":
+        source = content_block.get("source")
+        if isinstance(source, dict) and source.get("type") == "text":
+            return {
+                "type": "text",
+                "text": source.get("data", ""),
+            }
+
+    # Use Anthropic-specific transformation
+    result = transform_anthropic_content_part(content_block)
+    return result if result is not None else content_block
+
+
 def _set_input_data(
     span: "Span", kwargs: "dict[str, Any]", integration: "AnthropicIntegration"
 ) -> None:
@@ -166,19 +188,41 @@ def _set_input_data(
                 and "content" in message
                 and isinstance(message["content"], (list, tuple))
             ):
+                transformed_content = []
                 for item in message["content"]:
-                    if item.get("type") == "tool_result":
-                        normalized_messages.append(
-                            {
-                                "role": GEN_AI_ALLOWED_MESSAGE_ROLES.TOOL,
-                                "content": {  # type: ignore[dict-item]
-                                    "tool_use_id": item.get("tool_use_id"),
-                                    "output": item.get("content"),
-                                },
-                            }
-                        )
+                    # Skip tool_result items - they can contain images/documents
+                    # with nested structures that are difficult to redact properly
+                    if isinstance(item, dict) and item.get("type") == "tool_result":
+                        continue
+
+                    # Transform content blocks (images, documents, etc.)
+                    transformed_content.append(
+                        _transform_anthropic_content_block(item)
+                        if isinstance(item, dict)
+                        else item
+                    )
+
+                # If there are non-tool-result items, add them as a message
+                if transformed_content:
+                    normalized_messages.append(
+                        {
+                            "role": message.get("role"),
+                            "content": transformed_content,
+                        }
+                    )
             else:
-                normalized_messages.append(message)
+                # Transform content for non-list messages or assistant messages
+                transformed_message = message.copy()
+                if "content" in transformed_message:
+                    content = transformed_message["content"]
+                    if isinstance(content, (list, tuple)):
+                        transformed_message["content"] = [
+                            _transform_anthropic_content_block(item)
+                            if isinstance(item, dict)
+                            else item
+                            for item in content
+                        ]
+                normalized_messages.append(transformed_message)
 
         role_normalized_messages = normalize_message_roles(normalized_messages)
         scope = sentry_sdk.get_current_scope()

sentry_sdk/integrations/langchain.py

@@ -14,6 +14,7 @@
     normalize_message_roles,
     set_data_normalized,
     truncate_and_annotate_messages,
+    transform_content_part,
 )
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration
@@ -117,6 +118,39 @@
 }
 
 
+def _transform_langchain_content_block(
+    content_block: "Dict[str, Any]",
+) -> "Dict[str, Any]":
+    """
+    Transform a LangChain content block using the shared transform_content_part function.
+
+    Returns the original content block if transformation is not applicable
+    (e.g., for text blocks or unrecognized formats).
+    """
+    result = transform_content_part(content_block)
+    return result if result is not None else content_block
+
+
+def _transform_langchain_message_content(content: "Any") -> "Any":
+    """
+    Transform LangChain message content, handling both string content and
+    list of content blocks.
+    """
+    if isinstance(content, str):
+        return content
+
+    if isinstance(content, (list, tuple)):
+        transformed = []
+        for block in content:
+            if isinstance(block, dict):
+                transformed.append(_transform_langchain_content_block(block))
+            else:
+                transformed.append(block)
+        return transformed
+
+    return content
+
+
 # Contextvar to track agent names in a stack for re-entrant agent support
 _agent_stack: "contextvars.ContextVar[Optional[List[Optional[str]]]]" = (
     contextvars.ContextVar("langchain_agent_stack", default=None)
@@ -234,7 +268,9 @@ def _handle_error(self, run_id: "UUID", error: "Any") -> None:
             del self.span_map[run_id]
 
     def _normalize_langchain_message(self, message: "BaseMessage") -> "Any":
-        parsed = {"role": message.type, "content": message.content}
+        # Transform content to handle multimodal data (images, audio, video, files)
+        transformed_content = _transform_langchain_message_content(message.content)
+        parsed = {"role": message.type, "content": transformed_content}
         parsed.update(message.additional_kwargs)
         return parsed
 

sentry_sdk/utils.py

@@ -4,6 +4,7 @@
 import logging
 import math
 import os
+import copy
 import random
 import re
 import subprocess
@@ -2061,6 +2062,25 @@ def format_attribute(val: "Any") -> "AttributeValue":
     if isinstance(val, (bool, int, float, str)):
         return val
 
+    # Only lists of elements of a single type are supported
+    list_types: 'dict[type, Literal["string[]", "integer[]", "double[]", "boolean[]"]]' = {
+        str: "string[]",
+        int: "integer[]",
+        float: "double[]",
+        bool: "boolean[]",
+    }
+
+    if isinstance(val, (list, tuple)) and not val:
+        return []
+    elif isinstance(val, list):
+        ty = type(val[0])
+        if ty in list_types and all(type(v) is ty for v in val):
+            return copy.deepcopy(val)
+    elif isinstance(val, tuple):
+        ty = type(val[0])
+        if ty in list_types and all(type(v) is ty for v in val):
+            return list(val)
+
     return safe_repr(val)
 
 
@@ -2075,6 +2095,22 @@ def serialize_attribute(val: "AttributeValue") -> "SerializedAttributeValue":
     if isinstance(val, str):
         return {"value": val, "type": "string"}
 
+    if isinstance(val, list):
+        if not val:
+            return {"value": [], "type": "string[]"}
+
+        # Only lists of elements of a single type are supported
+        list_types: 'dict[type, Literal["string[]", "integer[]", "double[]", "boolean[]"]]' = {
+            str: "string[]",
+            int: "integer[]",
+            float: "double[]",
+            bool: "boolean[]",
+        }
+
+        ty = type(val[0])
+        if ty in list_types and all(type(v) is ty for v in val):
+            return {"value": val, "type": list_types[ty]}
+
     # Coerce to string if we don't know what to do with the value. This should
     # never happen as we pre-format early in format_attribute, but let's be safe.
     return {"value": safe_repr(val), "type": "string"}