Make sure to never send objects, but rather strings

Author: antonpirker

sentry_sdk/integrations/openai_agents/utils.py

@@ -1,3 +1,4 @@
+import json
 import sentry_sdk
 from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations import DidNotEnable
@@ -76,7 +77,7 @@ def _set_agent_data(span, agent):
     if len(agent.tools) > 0:
         span.set_data(
             SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS,
-            [vars(tool) for tool in agent.tools],
+            safe_serialize([vars(tool) for tool in agent.tools]),
         )
 
 
@@ -126,7 +127,7 @@ def _set_input_data(span, get_response_kwargs):
         if len(messages) > 0:
             request_messages.append({"role": role, "content": messages})
 
-    span.set_data(SPANDATA.GEN_AI_REQUEST_MESSAGES, request_messages)
+    span.set_data(SPANDATA.GEN_AI_REQUEST_MESSAGES, safe_serialize(request_messages))
 
 
 def _set_output_data(span, result):
@@ -148,10 +149,58 @@ def _set_output_data(span, result):
                     output_messages["response"].append(output_message.text)
                 except AttributeError:
                     # Unknown output message type, just return the json
-                    output_messages["response"].append(output_message.to_json())
+                    output_messages["response"].append(output_message.dict())
 
     if len(output_messages["tool"]) > 0:
-        span.set_data(SPANDATA.GEN_AI_RESPONSE_TOOL_CALLS, output_messages["tool"])
+        span.set_data(
+            SPANDATA.GEN_AI_RESPONSE_TOOL_CALLS, safe_serialize(output_messages["tool"])
+        )
 
     if len(output_messages["response"]) > 0:
-        span.set_data(SPANDATA.GEN_AI_RESPONSE_TEXT, output_messages["response"])
+        span.set_data(
+            SPANDATA.GEN_AI_RESPONSE_TEXT, safe_serialize(output_messages["response"])
+        )
+
+
+def safe_serialize(data):
+    """Safely serialize to a readable string."""
+
+    def serialize_item(item):
+        if callable(item):
+            try:
+                module = getattr(item, "__module__", None)
+                qualname = getattr(item, "__qualname__", None)
+                name = getattr(item, "__name__", "anonymous")
+
+                if module and qualname:
+                    full_path = f"{module}.{qualname}"
+                elif module and name:
+                    full_path = f"{module}.{name}"
+                else:
+                    full_path = name
+
+                return f"<function {full_path}>"
+            except Exception:
+                return f"<callable {type(item).__name__}>"
+        elif isinstance(item, dict):
+            return {k: serialize_item(v) for k, v in item.items()}
+        elif isinstance(item, (list, tuple)):
+            return [serialize_item(x) for x in item]
+        elif hasattr(item, "__dict__"):
+            try:
+                attrs = {
+                    k: serialize_item(v)
+                    for k, v in vars(item).items()
+                    if not k.startswith("_")
+                }
+                return f"<{type(item).__name__} {attrs}>"
+            except Exception:
+                return repr(item)
+        else:
+            return item
+
+    try:
+        serialized = serialize_item(data)
+        return json.dumps(serialized, default=str)
+    except Exception:
+        return str(data)

tests/integrations/openai_agents/test_openai_agents.py

@@ -1,9 +1,10 @@
-from unittest import mock
+import re
 import pytest
 from unittest.mock import MagicMock, patch
 import os
 
 from sentry_sdk.integrations.openai_agents import OpenAIAgentsIntegration
+from sentry_sdk.integrations.openai_agents.utils import safe_serialize
 
 import agents
 from agents import (
@@ -360,22 +361,24 @@ def simple_test_tool(message: str) -> str:
         ai_client_span2,
     ) = spans
 
-    available_tools = [
-        {
-            "name": "simple_test_tool",
-            "description": "A simple tool",
-            "params_json_schema": {
-                "properties": {"message": {"title": "Message", "type": "string"}},
-                "required": ["message"],
-                "title": "simple_test_tool_args",
-                "type": "object",
-                "additionalProperties": False,
-            },
-            "on_invoke_tool": mock.ANY,
-            "strict_json_schema": True,
-            "is_enabled": True,
-        }
-    ]
+    available_tools = safe_serialize(
+        [
+            {
+                "name": "simple_test_tool",
+                "description": "A simple tool",
+                "params_json_schema": {
+                    "properties": {"message": {"title": "Message", "type": "string"}},
+                    "required": ["message"],
+                    "title": "simple_test_tool_args",
+                    "type": "object",
+                    "additionalProperties": False,
+                },
+                "on_invoke_tool": "<function agents.tool.function_tool.<locals>._create_function_tool.<locals>._on_invoke_tool>",
+                "strict_json_schema": True,
+                "is_enabled": True,
+            }
+        ]
+    )
 
     assert transaction["transaction"] == "test_agent workflow"
     assert transaction["contexts"]["trace"]["origin"] == "auto.ai.openai_agents"
@@ -397,16 +400,22 @@ def simple_test_tool(message: str) -> str:
     assert ai_client_span1["data"]["gen_ai.agent.name"] == "test_agent"
     assert ai_client_span1["data"]["gen_ai.request.available_tools"] == available_tools
     assert ai_client_span1["data"]["gen_ai.request.max_tokens"] == 100
-    assert ai_client_span1["data"]["gen_ai.request.messages"] == [
-        {
-            "role": "system",
-            "content": [{"type": "text", "text": "You are a helpful test assistant."}],
-        },
-        {
-            "role": "user",
-            "content": [{"type": "text", "text": "Please use the simple test tool"}],
-        },
-    ]
+    assert ai_client_span1["data"]["gen_ai.request.messages"] == safe_serialize(
+        [
+            {
+                "role": "system",
+                "content": [
+                    {"type": "text", "text": "You are a helpful test assistant."}
+                ],
+            },
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "Please use the simple test tool"}
+                ],
+            },
+        ]
+    )
     assert ai_client_span1["data"]["gen_ai.request.model"] == "gpt-4"
     assert ai_client_span1["data"]["gen_ai.request.temperature"] == 0.7
     assert ai_client_span1["data"]["gen_ai.request.top_p"] == 1.0
@@ -415,22 +424,35 @@ def simple_test_tool(message: str) -> str:
     assert ai_client_span1["data"]["gen_ai.usage.output_tokens"] == 5
     assert ai_client_span1["data"]["gen_ai.usage.output_tokens.reasoning"] == 0
     assert ai_client_span1["data"]["gen_ai.usage.total_tokens"] == 15
-    assert ai_client_span1["data"]["gen_ai.response.tool_calls"] == [
-        {
-            "arguments": '{"message": "hello"}',
-            "call_id": "call_123",
-            "name": "simple_test_tool",
-            "type": "function_call",
-            "id": "call_123",
-            "status": None,
-            "function": mock.ANY,
-        }
-    ]
+    assert re.sub(
+        r"SerializationIterator\(.*\)",
+        "NOT_CHECKED",
+        ai_client_span1["data"]["gen_ai.response.tool_calls"],
+    ) == safe_serialize(
+        [
+            {
+                "arguments": '{"message": "hello"}',
+                "call_id": "call_123",
+                "name": "simple_test_tool",
+                "type": "function_call",
+                "id": "call_123",
+                "status": None,
+                "function": "NOT_CHECKED",
+            }
+        ]
+    )
 
     assert tool_span["description"] == "execute_tool simple_test_tool"
     assert tool_span["data"]["gen_ai.agent.name"] == "test_agent"
     assert tool_span["data"]["gen_ai.operation.name"] == "execute_tool"
-    assert tool_span["data"]["gen_ai.request.available_tools"] == available_tools
+    assert (
+        re.sub(
+            "<.*>(,)",
+            r"'NOT_CHECKED'\1",
+            agent_span["data"]["gen_ai.request.available_tools"],
+        )
+        == available_tools
+    )
     assert tool_span["data"]["gen_ai.request.max_tokens"] == 100
     assert tool_span["data"]["gen_ai.request.model"] == "gpt-4"
     assert tool_span["data"]["gen_ai.request.temperature"] == 0.7
@@ -445,47 +467,64 @@ def simple_test_tool(message: str) -> str:
     assert ai_client_span2["description"] == "chat gpt-4"
     assert ai_client_span2["data"]["gen_ai.agent.name"] == "test_agent"
     assert ai_client_span2["data"]["gen_ai.operation.name"] == "chat"
-    assert ai_client_span2["data"]["gen_ai.request.available_tools"] == available_tools
+    assert (
+        re.sub(
+            "<.*>(,)",
+            r"'NOT_CHECKED'\1",
+            agent_span["data"]["gen_ai.request.available_tools"],
+        )
+        == available_tools
+    )
     assert ai_client_span2["data"]["gen_ai.request.max_tokens"] == 100
-    assert ai_client_span2["data"]["gen_ai.request.messages"] == [
-        {
-            "role": "system",
-            "content": [{"type": "text", "text": "You are a helpful test assistant."}],
-        },
-        {
-            "role": "user",
-            "content": [{"type": "text", "text": "Please use the simple test tool"}],
-        },
-        {
-            "role": "assistant",
-            "content": [
-                {
-                    "arguments": '{"message": "hello"}',
-                    "call_id": "call_123",
-                    "name": "simple_test_tool",
-                    "type": "function_call",
-                    "id": "call_123",
-                    "function": mock.ANY,
-                }
-            ],
-        },
-        {
-            "role": "tool",
-            "content": [
-                {
-                    "call_id": "call_123",
-                    "output": "Tool executed with: hello",
-                    "type": "function_call_output",
-                }
-            ],
-        },
-    ]
+    assert re.sub(
+        r"SerializationIterator\(.*\)",
+        "NOT_CHECKED",
+        ai_client_span2["data"]["gen_ai.request.messages"],
+    ) == safe_serialize(
+        [
+            {
+                "role": "system",
+                "content": [
+                    {"type": "text", "text": "You are a helpful test assistant."}
+                ],
+            },
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "Please use the simple test tool"}
+                ],
+            },
+            {
+                "role": "assistant",
+                "content": [
+                    {
+                        "arguments": '{"message": "hello"}',
+                        "call_id": "call_123",
+                        "name": "simple_test_tool",
+                        "type": "function_call",
+                        "id": "call_123",
+                        "function": "NOT_CHECKED",
+                    }
+                ],
+            },
+            {
+                "role": "tool",
+                "content": [
+                    {
+                        "call_id": "call_123",
+                        "output": "Tool executed with: hello",
+                        "type": "function_call_output",
+                    }
+                ],
+            },
+        ]
+    )
     assert ai_client_span2["data"]["gen_ai.request.model"] == "gpt-4"
     assert ai_client_span2["data"]["gen_ai.request.temperature"] == 0.7
     assert ai_client_span2["data"]["gen_ai.request.top_p"] == 1.0
-    assert ai_client_span2["data"]["gen_ai.response.text"] == [
-        "Task completed using the tool"
-    ]
+    assert ai_client_span2["data"]["gen_ai.response.text"] == safe_serialize(
+        ["Task completed using the tool"]
+    )
     assert ai_client_span2["data"]["gen_ai.system"] == "openai"
     assert ai_client_span2["data"]["gen_ai.usage.input_tokens.cached"] == 0
     assert ai_client_span2["data"]["gen_ai.usage.input_tokens"] == 15