remove single message size truncation for now

Author: shellmayr

sentry_sdk/ai/utils.py

@@ -112,8 +112,10 @@ def truncate_messages_by_size(messages, max_bytes=MAX_GEN_AI_MESSAGE_BYTES):
     if not messages:
         return messages
 
+    # make a list out of the messages in case it's just a string? why is this needed?
     truncated_messages = list(messages)
 
+    # while there is more than one message, serialize and measure the size, and if it's too big, remove the oldest message
     while len(truncated_messages) > 1:
         serialized = serialize(
             truncated_messages, is_vars=False, max_value_length=round(max_bytes * 0.8)
@@ -126,24 +128,6 @@ def truncate_messages_by_size(messages, max_bytes=MAX_GEN_AI_MESSAGE_BYTES):
 
         truncated_messages.pop(0)
 
-    if len(truncated_messages) == 1:
-        last_message = truncated_messages[0].copy()
-        content = last_message.get("content", "")
-
-        if content and isinstance(content, str):
-            if len(content) > int(max_bytes * 0.8):
-                last_message["content"] = content[: int(max_bytes * 0.8)] + "..."
-            else:
-                last_message["content"] = content
-            truncated_messages[0] = last_message
-
-        if content and isinstance(content, list):
-            if len(content) > int(max_bytes * 0.8):
-                last_message["content"] = content[: int(max_bytes * 0.8)] + "..."
-            else:
-                last_message["content"] = content
-            truncated_messages[0] = last_message
-
     return truncated_messages
 
 

tests/integrations/anthropic/test_anthropic.py

@@ -989,51 +989,3 @@ def test_anthropic_message_truncation(sentry_init, capture_events):
 
     result_size = len(messages_data.encode("utf-8"))
     assert result_size <= MAX_GEN_AI_MESSAGE_BYTES
-
-
-def test_anthropic_single_large_message_preservation(sentry_init, capture_events):
-    """Test that a single very large message gets preserved with truncated content."""
-    sentry_init(
-        integrations=[AnthropicIntegration(include_prompts=True)],
-        traces_sample_rate=1.0,
-        send_default_pii=True,
-    )
-    events = capture_events()
-
-    client = Anthropic(api_key="test-api-key")
-    client.messages._post = mock.Mock(
-        return_value=Message(
-            id="test",
-            content=[TextBlock(text="Hello", type="text")],
-            model="claude-3",
-            role="assistant",
-            type="message",
-            usage=Usage(input_tokens=100, output_tokens=50),
-        )
-    )
-
-    huge_content = (
-        "This is an extremely long message that will definitely exceed size limits. "
-        * 2000
-    )
-    messages = [{"role": "user", "content": huge_content}]
-
-    with start_transaction(name="anthropic tx"):
-        client.messages.create(
-            model="claude-3-sonnet-20240229",
-            messages=messages,
-            max_tokens=100,
-        )
-
-    (event,) = events
-    (span,) = event["spans"]
-
-    assert SPANDATA.GEN_AI_REQUEST_MESSAGES in span["data"]
-    messages_data = span["data"][SPANDATA.GEN_AI_REQUEST_MESSAGES]
-    assert isinstance(messages_data, str)
-
-    parsed_messages = json.loads(messages_data)
-    assert isinstance(parsed_messages, list)
-    assert len(parsed_messages) == 1
-    assert parsed_messages[0]["role"] == "user"
-    assert len(parsed_messages[0]["content"]) < len(huge_content)

tests/integrations/litellm/test_litellm.py

@@ -599,48 +599,3 @@ def test_litellm_message_truncation(sentry_init, capture_events):
 
     result_size = len(messages_data.encode("utf-8"))
     assert result_size <= MAX_GEN_AI_MESSAGE_BYTES
-
-
-def test_litellm_single_large_message_preservation(sentry_init, capture_events):
-    """Test that a single very large message gets preserved with truncated content."""
-    sentry_init(
-        integrations=[LiteLLMIntegration(include_prompts=True)],
-        traces_sample_rate=1.0,
-        send_default_pii=True,
-    )
-    events = capture_events()
-
-    huge_content = (
-        "This is an extremely long message that will definitely exceed size limits. "
-        * 2000
-    )
-    messages = [{"role": "user", "content": huge_content}]
-
-    mock_response = MockCompletionResponse()
-
-    with start_transaction(name="litellm test"):
-        kwargs = {
-            "model": "gpt-3.5-turbo",
-            "messages": messages,
-        }
-
-        _input_callback(kwargs)
-        _success_callback(
-            kwargs,
-            mock_response,
-            datetime.now(),
-            datetime.now(),
-        )
-
-    (event,) = events
-    (span,) = event["spans"]
-
-    assert SPANDATA.GEN_AI_REQUEST_MESSAGES in span["data"]
-    messages_data = span["data"][SPANDATA.GEN_AI_REQUEST_MESSAGES]
-    assert isinstance(messages_data, str)
-
-    parsed_messages = json.loads(messages_data)
-    assert isinstance(parsed_messages, list)
-    assert len(parsed_messages) == 1
-    assert parsed_messages[0]["role"] == "user"
-    assert len(parsed_messages[0]["content"]) < len(huge_content)

tests/integrations/openai/test_openai.py

@@ -1554,44 +1554,3 @@ def test_openai_message_truncation(sentry_init, capture_events):
             if SPANDATA.GEN_AI_REQUEST_MESSAGES in span_meta:
                 messages_meta = span_meta[SPANDATA.GEN_AI_REQUEST_MESSAGES]
                 assert "len" in messages_meta.get("", {})
-
-
-def test_openai_single_large_message_content_truncation(sentry_init, capture_events):
-    """Test that a single very large message gets content truncated, not removed entirely."""
-    sentry_init(
-        integrations=[OpenAIIntegration(include_prompts=True)],
-        traces_sample_rate=1.0,
-        send_default_pii=True,
-    )
-    events = capture_events()
-
-    client = OpenAI(api_key="z")
-    client.chat.completions._post = mock.Mock(return_value=EXAMPLE_CHAT_COMPLETION)
-
-    huge_content = (
-        "This is an extremely long message that will definitely exceed size limits. "
-        * 2000
-    )
-    messages = [{"role": "user", "content": huge_content}]
-
-    with start_transaction(name="openai tx"):
-        client.chat.completions.create(
-            model="some-model",
-            messages=messages,
-        )
-
-    (event,) = events
-    span = event["spans"][0]
-    assert SPANDATA.GEN_AI_REQUEST_MESSAGES in span["data"]
-
-    messages_data = span["data"][SPANDATA.GEN_AI_REQUEST_MESSAGES]
-    assert isinstance(messages_data, str)
-
-    parsed_messages = json.loads(messages_data)
-    assert isinstance(parsed_messages, list)
-    assert len(parsed_messages) == 1
-    assert parsed_messages[0]["role"] == "user"
-    assert len(parsed_messages[0]["content"]) < len(huge_content)
-
-    result_size = len(messages_data.encode("utf-8"))
-    assert result_size <= MAX_GEN_AI_MESSAGE_BYTES

tests/integrations/openai_agents/test_openai_agents.py

@@ -1130,57 +1130,3 @@ def test_openai_agents_message_truncation(
     total_original_size = len(large_system_prompt) + len(large_user_message)
     total_parsed_size = sum(len(str(msg)) for msg in parsed_messages)
     assert total_parsed_size < total_original_size
-
-
-def test_openai_agents_single_large_message_preservation(
-    sentry_init, capture_events, mock_model_response
-):
-    """Test that a single very large message gets preserved with truncated content."""
-    huge_content = (
-        "This is an extremely long message that will definitely exceed size limits. "
-        * 2000
-    )
-
-    agent = Agent(
-        name="test_agent",
-        model="gpt-4",
-        instructions="You are helpful.",
-    )
-
-    with patch.dict(os.environ, {"OPENAI_API_KEY": "test-key"}):
-        with patch(
-            "agents.models.openai_responses.OpenAIResponsesModel.get_response"
-        ) as mock_get_response:
-            mock_get_response.return_value = mock_model_response
-
-            sentry_init(
-                integrations=[OpenAIAgentsIntegration()],
-                traces_sample_rate=1.0,
-                send_default_pii=True,
-            )
-
-            events = capture_events()
-
-            result = agents.Runner.run_sync(
-                agent, huge_content, run_config=test_run_config
-            )
-
-            assert result is not None
-
-    (event,) = events
-    spans = event["spans"]
-    invoke_agent_span, ai_client_span = spans
-    assert "gen_ai.request.messages" in invoke_agent_span["data"]
-
-    messages_data = invoke_agent_span["data"]["gen_ai.request.messages"]
-    assert isinstance(messages_data, str)
-
-    parsed_messages = json.loads(messages_data)
-    assert isinstance(parsed_messages, list)
-    assert len(parsed_messages) >= 1
-
-    user_message = next(
-        (msg for msg in parsed_messages if msg.get("role") == "user"), None
-    )
-    if user_message and "content" in user_message:
-        assert len(user_message["content"]) < len(huge_content)

tests/test_ai_message_utils.py

@@ -9,6 +9,7 @@
 )
 from sentry_sdk._types import AnnotatedValue
 from sentry_sdk.serializer import serialize
+from sentry_sdk.utils import safe_serialize
 
 
 @pytest.fixture
@@ -69,24 +70,6 @@ def test_empty_messages_list(self):
         )
         assert result == []
 
-    def test_single_message_under_limit(self):
-        """Test single message under size limit"""
-        messages = [{"role": "user", "content": "Hello!"}]
-        result = truncate_messages_by_size(
-            messages, max_bytes=MAX_GEN_AI_MESSAGE_BYTES // 500
-        )
-        assert result == messages
-
-    def test_single_message_over_limit(self):
-        """Test single message that exceeds size limit"""
-        large_content = "x" * 10000
-        messages = [{"role": "user", "content": large_content}]
-
-        result = truncate_messages_by_size(messages, max_bytes=100)
-        assert len(result) == 1
-        assert result[0]["role"] == "user"
-        assert len(result[0]["content"]) < len(large_content)
-
     def test_progressive_truncation(self, large_messages):
         """Test that truncation works progressively with different limits"""
         limits = [
@@ -288,7 +271,8 @@ def __init__(self):
             orig_count = span_data.pop("_gen_ai_messages_original_count", None)
             if orig_count is not None and SPANDATA.GEN_AI_REQUEST_MESSAGES in span_data:
                 span_data[SPANDATA.GEN_AI_REQUEST_MESSAGES] = AnnotatedValue(
-                    span_data[SPANDATA.GEN_AI_REQUEST_MESSAGES], {"len": orig_count}
+                    safe_serialize(span_data[SPANDATA.GEN_AI_REQUEST_MESSAGES]),
+                    {"len": orig_count},
                 )
 
         # Verify the annotation happened