more tests & fixes

Author: mydea

dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/server.ts

@@ -5,7 +5,7 @@ Sentry.init({
   dsn: 'https://[email protected]/1337',
   release: '1.0',
   transport: loggingTransport,
-  tracesSampleRate: 1,
+  tracesSampleRate: 0
 });
 
 import express from 'express';

dev-packages/node-integration-tests/suites/express/handle-error-tracesSampleRate-0/test.ts

@@ -7,7 +7,6 @@ afterAll(() => {
 
 test('should capture and send Express controller error with txn name if tracesSampleRate is 0', async () => {
   const runner = createRunner(__dirname, 'server.ts')
-    .ignore('transaction')
     .expect({
       event: {
         exception: {

dev-packages/node-integration-tests/suites/express/handle-error/server.ts

@@ -0,0 +1,21 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  release: '1.0',
+  tracesSampleRate: 1,
+  transport: loggingTransport,
+});
+
+import express from 'express';
+
+const app = express();
+
+app.get('/test/express/:id', req => {
+  throw new Error(`test_error with id ${req.params.id}`);
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/express/handle-error/test.ts

@@ -0,0 +1,44 @@
+import { afterAll, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('should capture and send Express controller error with txn name if tracesSampleRate is 1', async () => {
+  const runner = createRunner(__dirname, 'server.ts')
+    .expect({
+      transaction: {
+        transaction: 'GET /test/express/:id',
+      },
+    })
+    .expect({
+      event: {
+        exception: {
+          values: [
+            {
+              mechanism: {
+                type: 'middleware',
+                handled: false,
+              },
+              type: 'Error',
+              value: 'test_error with id 123',
+              stacktrace: {
+                frames: expect.arrayContaining([
+                  expect.objectContaining({
+                    function: expect.any(String),
+                    lineno: expect.any(Number),
+                    colno: expect.any(Number),
+                  }),
+                ]),
+              },
+            },
+          ],
+        },
+        transaction: 'GET /test/express/:id',
+      },
+    })
+    .start();
+  runner.makeRequest('get', '/test/express/123', { expectError: true });
+  await runner.completed();
+});

dev-packages/node-integration-tests/suites/tracing/vercelai/scenario-error-in-tool-express.mjs

@@ -0,0 +1,50 @@
+import * as Sentry from '@sentry/node';
+import { generateText } from 'ai';
+import { MockLanguageModelV1 } from 'ai/test';
+import { z } from 'zod';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+
+const app = express();
+
+app.get('/test/error-in-tool', async (_req, res, next) => {
+  Sentry.setTag('test-tag', 'test-value');
+
+  try {
+    await generateText({
+      model: new MockLanguageModelV1({
+        doGenerate: async () => ({
+          rawCall: { rawPrompt: null, rawSettings: {} },
+          finishReason: 'tool-calls',
+          usage: { promptTokens: 15, completionTokens: 25 },
+          text: 'Tool call completed!',
+          toolCalls: [
+            {
+              toolCallType: 'function',
+              toolCallId: 'call-1',
+              toolName: 'getWeather',
+              args: '{ "location": "San Francisco" }',
+            },
+          ],
+        }),
+      }),
+      tools: {
+        getWeather: {
+          parameters: z.object({ location: z.string() }),
+          execute: async () => {
+            throw new Error('Error in tool');
+          },
+        },
+      },
+      prompt: 'What is the weather in San Francisco?',
+    });
+  } catch (error) {
+    next(error);
+    return;
+  }
+
+  res.send({ message: 'OK' });
+});
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/tracing/vercelai/scenario-error-in-tool.mjs

@@ -4,6 +4,8 @@ import { MockLanguageModelV1 } from 'ai/test';
 import { z } from 'zod';
 
 async function run() {
+  Sentry.setTag('test-tag', 'test-value');
+
   await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
     await generateText({
       model: new MockLanguageModelV1({

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

@@ -1,5 +1,6 @@
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
+import { Event } from '@sentry/node';
 
 describe('Vercel AI integration', () => {
   afterAll(() => {
@@ -485,6 +486,10 @@ describe('Vercel AI integration', () => {
             status: 'unknown_error',
           }),
         ]),
+
+        tags: {
+          'test-tag': 'test-value',
+        },
       };
 
       let traceId: string = 'unset-trace-id';
@@ -505,6 +510,9 @@ describe('Vercel AI integration', () => {
             }),
           ]),
         },
+        tags: {
+          'test-tag': 'test-value',
+        },
       };
 
       await createRunner()
@@ -526,4 +534,129 @@ describe('Vercel AI integration', () => {
         .completed();
     });
   });
+
+  createEsmAndCjsTests(__dirname, 'scenario-error-in-tool-express.mjs', 'instrument.mjs', (createRunner, test) => {
+    test('captures error in tool in express server', async () => {
+      const expectedTransaction = {
+        transaction: 'GET /test/error-in-tool',
+        spans: expect.arrayContaining([
+          expect.objectContaining({
+            data: {
+              'vercel.ai.model.id': 'mock-model-id',
+              'vercel.ai.model.provider': 'mock-provider',
+              'vercel.ai.operationId': 'ai.generateText',
+              'vercel.ai.pipeline.name': 'generateText',
+              'vercel.ai.settings.maxRetries': 2,
+              'vercel.ai.settings.maxSteps': 1,
+              'vercel.ai.streaming': false,
+              'gen_ai.response.model': 'mock-model-id',
+              'operation.name': 'ai.generateText',
+              'sentry.op': 'gen_ai.invoke_agent',
+              'sentry.origin': 'auto.vercelai.otel',
+            },
+            description: 'generateText',
+            op: 'gen_ai.invoke_agent',
+            origin: 'auto.vercelai.otel',
+            status: 'unknown_error',
+          }),
+          expect.objectContaining({
+            data: {
+              'vercel.ai.model.id': 'mock-model-id',
+              'vercel.ai.model.provider': 'mock-provider',
+              'vercel.ai.operationId': 'ai.generateText.doGenerate',
+              'vercel.ai.pipeline.name': 'generateText.doGenerate',
+              'vercel.ai.response.finishReason': 'tool-calls',
+              'vercel.ai.response.id': expect.any(String),
+              'vercel.ai.response.model': 'mock-model-id',
+              'vercel.ai.response.timestamp': expect.any(String),
+              'vercel.ai.settings.maxRetries': 2,
+              'vercel.ai.streaming': false,
+              'gen_ai.request.model': 'mock-model-id',
+              'gen_ai.response.finish_reasons': ['tool-calls'],
+              'gen_ai.response.id': expect.any(String),
+              'gen_ai.response.model': 'mock-model-id',
+              'gen_ai.system': 'mock-provider',
+              'gen_ai.usage.input_tokens': 15,
+              'gen_ai.usage.output_tokens': 25,
+              'gen_ai.usage.total_tokens': 40,
+              'operation.name': 'ai.generateText.doGenerate',
+              'sentry.op': 'gen_ai.generate_text',
+              'sentry.origin': 'auto.vercelai.otel',
+            },
+            description: 'generate_text mock-model-id',
+            op: 'gen_ai.generate_text',
+            origin: 'auto.vercelai.otel',
+            status: 'ok',
+          }),
+          expect.objectContaining({
+            data: {
+              'vercel.ai.operationId': 'ai.toolCall',
+              'gen_ai.tool.call.id': 'call-1',
+              'gen_ai.tool.name': 'getWeather',
+              'gen_ai.tool.type': 'function',
+              'operation.name': 'ai.toolCall',
+              'sentry.op': 'gen_ai.execute_tool',
+              'sentry.origin': 'auto.vercelai.otel',
+            },
+            description: 'execute_tool getWeather',
+            op: 'gen_ai.execute_tool',
+            origin: 'auto.vercelai.otel',
+            status: 'unknown_error',
+          }),
+        ]),
+
+        tags: {
+          'test-tag': 'test-value',
+        },
+      };
+
+      const expectedError = {
+        contexts: {
+          trace: {
+            span_id: expect.any(String),
+            trace_id: expect.any(String),
+          },
+        },
+        exception: {
+          values: expect.arrayContaining([
+            expect.objectContaining({
+              type: 'AI_ToolExecutionError',
+              value: 'Error executing tool getWeather: Error in tool',
+            }),
+          ]),
+        },
+        tags: {
+          'test-tag': 'test-value',
+        },
+      };
+
+      let transactionEvent: Event | undefined;
+      let errorEvent: Event | undefined;
+
+      const runner = await createRunner()
+        .expect({
+          transaction: transaction => {
+            transactionEvent = transaction;
+          },
+        })
+        .expect({
+          event: event => {
+            errorEvent = event;
+          },
+        })
+        .start();
+
+      await runner.makeRequest('get', '/test/error-in-tool', { expectError: true });
+      await runner.completed();
+
+      expect(transactionEvent).toBeDefined();
+      expect(errorEvent).toBeDefined();
+
+      expect(transactionEvent).toMatchObject(expectedTransaction);
+
+      expect(errorEvent).toMatchObject(expectedError);
+      expect(errorEvent!.contexts!.trace!.trace_id).toBe(transactionEvent!.contexts!.trace!.trace_id);
+      expect(errorEvent!.contexts!.trace!.span_id).toBe(transactionEvent!.contexts!.trace!.span_id);
+    });
+  });
 });