feat(core): Truncate request string inputs in OpenAI integration (#18136)

The main OpenAI APIs are the
[completions](https://platform.openai.com/docs/api-reference/completions/create)
and
[responses](https://platform.openai.com/docs/api-reference/responses/create)
API. Currently we truncate messages sent to the API only if the user
input is an array of strings. This works for the completions, but not
for the responses API (where the input is a plain string).

Updated the truncation logic to also truncate if the input is a plain
string (+ test to verify everything works now as expected).

Author: nicohrubec

dev-packages/node-integration-tests/suites/tracing/openai/scenario-message-truncation.mjs renamed to dev-packages/node-integration-tests/suites/tracing/openai/scenario-message-truncation-completions.mjs

@@ -12,7 +12,7 @@ class MockOpenAI {
           await new Promise(resolve => setTimeout(resolve, 10));
 
           return {
-            id: 'chatcmpl-truncation-test',
+            id: 'chatcmpl-completions-truncation-test',
             object: 'chat.completion',
             created: 1677652288,
             model: params.model,

dev-packages/node-integration-tests/suites/tracing/openai/scenario-message-truncation-responses.mjs

@@ -0,0 +1,93 @@
+import { instrumentOpenAiClient } from '@sentry/core';
+import * as Sentry from '@sentry/node';
+
+class MockOpenAI {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+
+    this.responses = {
+      create: async params => {
+        // Simulate processing time
+        await new Promise(resolve => setTimeout(resolve, 10));
+
+        return {
+          id: 'chatcmpl-responses-truncation-test',
+          object: 'response',
+          created_at: 1677652288,
+          status: 'completed',
+          error: null,
+          incomplete_details: null,
+          instructions: null,
+          max_output_tokens: null,
+          model: params.model,
+          output: [
+            {
+              type: 'message',
+              id: 'message-123',
+              status: 'completed',
+              role: 'assistant',
+              content: [
+                {
+                  type: 'output_text',
+                  text: 'Response to truncated messages',
+                  annotations: [],
+                },
+              ],
+            },
+          ],
+          parallel_tool_calls: true,
+          previous_response_id: null,
+          reasoning: {
+            effort: null,
+            summary: null,
+          },
+          store: true,
+          temperature: params.temperature,
+          text: {
+            format: {
+              type: 'text',
+            },
+          },
+          tool_choice: 'auto',
+          tools: [],
+          top_p: 1.0,
+          truncation: 'disabled',
+          usage: {
+            input_tokens: 10,
+            input_tokens_details: {
+              cached_tokens: 0,
+            },
+            output_tokens: 15,
+            output_tokens_details: {
+              reasoning_tokens: 0,
+            },
+            total_tokens: 25,
+          },
+          user: null,
+          metadata: {},
+        };
+      },
+    };
+  }
+}
+
+async function run() {
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    const mockClient = new MockOpenAI({
+      apiKey: 'mock-api-key',
+    });
+
+    const client = instrumentOpenAiClient(mockClient);
+
+    // Create 1 large message that gets truncated to fit within the 20KB limit
+    const largeContent = 'A'.repeat(25000) + 'B'.repeat(25000); // ~50KB gets truncated to include only As
+
+    await client.responses.create({
+      model: 'gpt-3.5-turbo',
+      input: largeContent,
+      temperature: 0.7,
+    });
+  });
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/openai/test.ts

@@ -400,7 +400,7 @@ describe('OpenAI integration', () => {
 
   createEsmAndCjsTests(
     __dirname,
-    'scenario-message-truncation.mjs',
+    'scenario-message-truncation-completions.mjs',
     'instrument-with-pii.mjs',
     (createRunner, test) => {
       test('truncates messages when they exceed byte limit - keeps only last message and crops it', async () => {
@@ -433,4 +433,40 @@ describe('OpenAI integration', () => {
       });
     },
   );
+
+  createEsmAndCjsTests(
+    __dirname,
+    'scenario-message-truncation-responses.mjs',
+    'instrument-with-pii.mjs',
+    (createRunner, test) => {
+      test('truncates string inputs when they exceed byte limit', async () => {
+        await createRunner()
+          .ignore('event')
+          .expect({
+            transaction: {
+              transaction: 'main',
+              spans: expect.arrayContaining([
+                expect.objectContaining({
+                  data: expect.objectContaining({
+                    'gen_ai.operation.name': 'responses',
+                    'sentry.op': 'gen_ai.responses',
+                    'sentry.origin': 'auto.ai.openai',
+                    'gen_ai.system': 'openai',
+                    'gen_ai.request.model': 'gpt-3.5-turbo',
+                    // Messages should be present and should include truncated string input (contains only As)
+                    'gen_ai.request.messages': expect.stringMatching(/^A+$/),
+                  }),
+                  description: 'responses gpt-3.5-turbo',
+                  op: 'gen_ai.responses',
+                  origin: 'auto.ai.openai',
+                  status: 'ok',
+                }),
+              ]),
+            },
+          })
+          .start()
+          .completed();
+      });
+    },
+  );
 });

packages/core/src/utils/ai/messageTruncation.ts

@@ -294,3 +294,13 @@ export function truncateMessagesByBytes(messages: unknown[], maxBytes: number):
 export function truncateGenAiMessages(messages: unknown[]): unknown[] {
   return truncateMessagesByBytes(messages, DEFAULT_GEN_AI_MESSAGES_BYTE_LIMIT);
 }
+
+/**
+ * Truncate GenAI string input using the default byte limit.
+ *
+ * @param input - The string to truncate
+ * @returns Truncated string
+ */
+export function truncateGenAiStringInput(input: string): string {
+  return truncateTextByBytes(input, DEFAULT_GEN_AI_MESSAGES_BYTE_LIMIT);
+}

packages/core/src/utils/ai/utils.ts

@@ -7,7 +7,7 @@ import {
   GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
   GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
 } from './gen-ai-attributes';
-import { truncateGenAiMessages } from './messageTruncation';
+import { truncateGenAiMessages, truncateGenAiStringInput } from './messageTruncation';
 /**
  * Maps AI method paths to Sentry operation name
  */
@@ -95,7 +95,7 @@ export function setTokenUsageAttributes(
 export function getTruncatedJsonString<T>(value: T | T[]): string {
   if (typeof value === 'string') {
     // Some values are already JSON strings, so we don't need to duplicate the JSON parsing
-    return value;
+    return truncateGenAiStringInput(value);
   }
   if (Array.isArray(value)) {
     // truncateGenAiMessages returns an array of strings, so we need to stringify it