feat(core): Automatically disable truncation when span streaming is enabled in Google

GenAI integration

When span streaming is enabled, the `enableTruncation` option now defaults
to `false` unless the user has explicitly set it.

Closes: #20223

Author: andreiborza

dev-packages/node-integration-tests/suites/tracing/google-genai/instrument-streaming-with-truncation.mjs

@@ -0,0 +1,16 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  sendDefaultPii: true,
+  transport: loggingTransport,
+  traceLifecycle: 'stream',
+  integrations: [
+    Sentry.googleGenAIIntegration({
+      enableTruncation: true,
+    }),
+  ],
+});

dev-packages/node-integration-tests/suites/tracing/google-genai/instrument-streaming.mjs

@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  sendDefaultPii: true,
+  transport: loggingTransport,
+  traceLifecycle: 'stream',
+});

dev-packages/node-integration-tests/suites/tracing/google-genai/scenario-span-streaming.mjs

@@ -0,0 +1,51 @@
+import { GoogleGenAI } from '@google/genai';
+import * as Sentry from '@sentry/node';
+import express from 'express';
+
+function startMockGoogleGenAIServer() {
+  const app = express();
+  app.use(express.json({ limit: '10mb' }));
+
+  app.post('/v1beta/models/:model\\:generateContent', (req, res) => {
+    res.json({
+      candidates: [
+        {
+          content: { parts: [{ text: 'Response' }], role: 'model' },
+          finishReason: 'STOP',
+        },
+      ],
+      usageMetadata: { promptTokenCount: 10, candidatesTokenCount: 5, totalTokenCount: 15 },
+    });
+  });
+
+  return new Promise(resolve => {
+    const server = app.listen(0, () => {
+      resolve(server);
+    });
+  });
+}
+
+async function run() {
+  const server = await startMockGoogleGenAIServer();
+
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    const client = new GoogleGenAI({
+      apiKey: 'mock-api-key',
+      httpOptions: { baseUrl: `http://localhost:${server.address().port}` },
+    });
+
+    // Long content that would normally be truncated
+    const longContent = 'A'.repeat(50_000);
+    await client.models.generateContent({
+      model: 'gemini-1.5-flash',
+      contents: [{ role: 'user', parts: [{ text: longContent }] }],
+    });
+  });
+
+  // Flush is required when span streaming is enabled to ensure streamed spans are sent before the process exits
+  await Sentry.flush(2000);
+
+  server.close();
+}
+
+run();

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

@@ -686,4 +686,55 @@ describe('Google GenAI integration', () => {
       });
     },
   );
+
+  const streamingLongContent = 'A'.repeat(50_000);
+
+  createEsmAndCjsTests(__dirname, 'scenario-span-streaming.mjs', 'instrument-streaming.mjs', (createRunner, test) => {
+    test('automatically disables truncation when span streaming is enabled', async () => {
+      await createRunner()
+        .expect({
+          span: container => {
+            const spans = container.items;
+
+            const expectedMessages = JSON.stringify([{ role: 'user', parts: [{ text: streamingLongContent }] }]);
+            const chatSpan = spans.find(
+              s => s.attributes?.[GEN_AI_INPUT_MESSAGES_ATTRIBUTE]?.value === expectedMessages,
+            );
+            expect(chatSpan).toBeDefined();
+          },
+        })
+        .start()
+        .completed();
+    });
+  });
+
+  createEsmAndCjsTests(
+    __dirname,
+    'scenario-span-streaming.mjs',
+    'instrument-streaming-with-truncation.mjs',
+    (createRunner, test) => {
+      test('respects explicit enableTruncation: true even when span streaming is enabled', async () => {
+        await createRunner()
+          .expect({
+            span: container => {
+              const spans = container.items;
+
+              // With explicit enableTruncation: true, content should be truncated despite streaming.
+              // Find the chat span by matching the start of the truncated content (the 'A' repeated messages).
+              const chatSpan = spans.find(s =>
+                s.attributes?.[GEN_AI_INPUT_MESSAGES_ATTRIBUTE]?.value?.startsWith(
+                  '[{"role":"user","parts":[{"text":"AAAA',
+                ),
+              );
+              expect(chatSpan).toBeDefined();
+              expect(chatSpan!.attributes[GEN_AI_INPUT_MESSAGES_ATTRIBUTE].value.length).toBeLessThan(
+                streamingLongContent.length,
+              );
+            },
+          })
+          .start()
+          .completed();
+      });
+    },
+  );
 });

packages/core/src/tracing/google-genai/index.ts

@@ -1,7 +1,9 @@
 /* eslint-disable max-lines */
+import { getClient } from '../../currentScopes';
 import { captureException } from '../../exports';
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '../../semanticAttributes';
 import { SPAN_STATUS_ERROR } from '../../tracing';
+import { hasSpanStreamingEnabled } from '../../tracing/spans/hasSpanStreamingEnabled';
 import { startSpan, startSpanManual } from '../../tracing/trace';
 import type { Span, SpanAttributeValue } from '../../types-hoist/span';
 import { handleCallbackErrors } from '../../utils/handleCallbackErrors';
@@ -297,7 +299,9 @@ function instrumentMethod<T extends unknown[], R>(
           async (span: Span) => {
             try {
               if (options.recordInputs && params) {
-                addPrivateRequestAttributes(span, params, isEmbeddings, options.enableTruncation ?? true);
+                const client = getClient();
+                const enableTruncation = options.enableTruncation ?? !(client && hasSpanStreamingEnabled(client));
+                addPrivateRequestAttributes(span, params, isEmbeddings, enableTruncation);
               }
               const stream = await target.apply(context, args);
               return instrumentStream(stream, span, Boolean(options.recordOutputs)) as R;
@@ -325,7 +329,9 @@ function instrumentMethod<T extends unknown[], R>(
         },
         (span: Span) => {
           if (options.recordInputs && params) {
-            addPrivateRequestAttributes(span, params, isEmbeddings, options.enableTruncation ?? true);
+            const client = getClient();
+            const enableTruncation = options.enableTruncation ?? !(client && hasSpanStreamingEnabled(client));
+            addPrivateRequestAttributes(span, params, isEmbeddings, enableTruncation);
           }
 
           return handleCallbackErrors(