Merge branch 'develop' into msgs-drop-media

Author: naaa760

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+Work in this release was contributed by @stefanvanderwolf. Thank you for your contribution!
+
 ## 10.17.0
 
 ### Important Changes

dev-packages/node-integration-tests/suites/tracing/vercelai/scenario-generate-object.mjs

@@ -0,0 +1,30 @@
+import * as Sentry from '@sentry/node';
+import { generateObject } from 'ai';
+import { MockLanguageModelV1 } from 'ai/test';
+import { z } from 'zod';
+
+async function run() {
+  await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
+    // Test generateObject with schema
+    await generateObject({
+      model: new MockLanguageModelV1({
+        defaultObjectGenerationMode: 'json',
+        doGenerate: async () => ({
+          rawCall: { rawPrompt: null, rawSettings: {} },
+          finishReason: 'stop',
+          usage: { promptTokens: 15, completionTokens: 25 },
+          text: '{ "name": "John Doe", "age": 30 }',
+        }),
+      }),
+      schema: z.object({
+        name: z.string().describe('The name of the person'),
+        age: z.number().describe('The age of the person'),
+      }),
+      schemaName: 'Person',
+      schemaDescription: 'A person with name and age',
+      prompt: 'Generate a person object',
+    });
+  });
+}
+
+run();

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

@@ -0,0 +1,67 @@
+import { afterAll, describe, expect } from 'vitest';
+import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
+
+describe('Vercel AI integration - generateObject', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  const EXPECTED_TRANSACTION = {
+    transaction: 'main',
+    spans: expect.arrayContaining([
+      // generateObject span
+      expect.objectContaining({
+        data: expect.objectContaining({
+          'vercel.ai.model.id': 'mock-model-id',
+          'vercel.ai.model.provider': 'mock-provider',
+          'vercel.ai.operationId': 'ai.generateObject',
+          'vercel.ai.pipeline.name': 'generateObject',
+          'vercel.ai.streaming': false,
+          'vercel.ai.settings.mode': 'json',
+          'vercel.ai.settings.output': 'object',
+          'gen_ai.request.schema': expect.any(String),
+          'gen_ai.response.model': 'mock-model-id',
+          'gen_ai.usage.input_tokens': 15,
+          'gen_ai.usage.output_tokens': 25,
+          'gen_ai.usage.total_tokens': 40,
+          'operation.name': 'ai.generateObject',
+          'sentry.op': 'gen_ai.invoke_agent',
+          'sentry.origin': 'auto.vercelai.otel',
+        }),
+        description: 'generateObject',
+        op: 'gen_ai.invoke_agent',
+        origin: 'auto.vercelai.otel',
+        status: 'ok',
+      }),
+      // generateObject.doGenerate span
+      expect.objectContaining({
+        data: expect.objectContaining({
+          'sentry.origin': 'auto.vercelai.otel',
+          'sentry.op': 'gen_ai.generate_object',
+          'operation.name': 'ai.generateObject.doGenerate',
+          'vercel.ai.operationId': 'ai.generateObject.doGenerate',
+          'vercel.ai.model.provider': 'mock-provider',
+          'vercel.ai.model.id': 'mock-model-id',
+          'vercel.ai.pipeline.name': 'generateObject.doGenerate',
+          'vercel.ai.streaming': false,
+          'gen_ai.system': 'mock-provider',
+          'gen_ai.request.model': 'mock-model-id',
+          'gen_ai.response.model': 'mock-model-id',
+          'gen_ai.usage.input_tokens': 15,
+          'gen_ai.usage.output_tokens': 25,
+          'gen_ai.usage.total_tokens': 40,
+        }),
+        description: 'generate_object mock-model-id',
+        op: 'gen_ai.generate_object',
+        origin: 'auto.vercelai.otel',
+        status: 'ok',
+      }),
+    ]),
+  };
+
+  createEsmAndCjsTests(__dirname, 'scenario-generate-object.mjs', 'instrument.mjs', (createRunner, test) => {
+    test('captures generateObject spans with schema attributes', async () => {
+      await createRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+    });
+  });
+});

packages/core/src/utils/vercel-ai/index.ts

@@ -18,6 +18,7 @@ import {
   AI_RESPONSE_PROVIDER_METADATA_ATTRIBUTE,
   AI_RESPONSE_TEXT_ATTRIBUTE,
   AI_RESPONSE_TOOL_CALLS_ATTRIBUTE,
+  AI_SCHEMA_ATTRIBUTE,
   AI_TELEMETRY_FUNCTION_ID_ATTRIBUTE,
   AI_TOOL_CALL_ARGS_ATTRIBUTE,
   AI_TOOL_CALL_ID_ATTRIBUTE,
@@ -135,6 +136,8 @@ function processEndedVercelAiSpan(span: SpanJSON): void {
   renameAttributeKey(attributes, AI_TOOL_CALL_ARGS_ATTRIBUTE, 'gen_ai.tool.input');
   renameAttributeKey(attributes, AI_TOOL_CALL_RESULT_ATTRIBUTE, 'gen_ai.tool.output');
 
+  renameAttributeKey(attributes, AI_SCHEMA_ATTRIBUTE, 'gen_ai.request.schema');
+
   addProviderMetadataToAttributes(attributes);
 
   // Change attributes namespaced with `ai.X` to `vercel.ai.X`

packages/nestjs/src/integrations/sentry-nest-event-instrumentation.ts

@@ -74,10 +74,18 @@ export class SentryNestEventInstrumentation extends InstrumentationBase {
             return decoratorResult(target, propertyKey, descriptor);
           }
 
+          function eventNameFromEvent(event: unknown): string {
+            if (typeof event === 'string') {
+              return event;
+            } else if (Array.isArray(event)) {
+              return event.map(eventNameFromEvent).join(',');
+            } else return String(event);
+          }
+
           const originalHandler = descriptor.value;
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
           const handlerName = originalHandler.name || propertyKey;
-          let eventName = typeof event === 'string' ? event : String(event);
+          let eventName = eventNameFromEvent(event);
 
           // Instrument the actual handler
           descriptor.value = async function (...args: unknown[]) {
@@ -93,7 +101,7 @@ export class SentryNestEventInstrumentation extends InstrumentationBase {
                 eventName = eventData
                   .map((data: unknown) => {
                     if (data && typeof data === 'object' && 'event' in data && data.event) {
-                      return data.event;
+                      return eventNameFromEvent(data.event);
                     }
                     return '';
                   })

packages/nestjs/test/integrations/nest.test.ts

@@ -75,17 +75,72 @@ describe('Nest', () => {
 
         await descriptor.value();
 
-        expect(core.startSpan).toHaveBeenCalled();
+        expect(core.startSpan).toHaveBeenCalledWith(
+          expect.objectContaining({
+            name: 'event test.event',
+          }),
+          expect.any(Function),
+        );
         expect(originalHandler).toHaveBeenCalled();
       });
 
-      it('should wrap array event handlers', async () => {
+      it('should wrap symbol event handlers', async () => {
+        const decorated = wrappedOnEvent(Symbol('test.event'));
+        decorated(mockTarget, 'testMethod', descriptor);
+
+        await descriptor.value();
+
+        expect(core.startSpan).toHaveBeenCalledWith(
+          expect.objectContaining({
+            name: 'event Symbol(test.event)',
+          }),
+          expect.any(Function),
+        );
+        expect(originalHandler).toHaveBeenCalled();
+      });
+
+      it('should wrap string array event handlers', async () => {
         const decorated = wrappedOnEvent(['test.event1', 'test.event2']);
         decorated(mockTarget, 'testMethod', descriptor);
 
         await descriptor.value();
 
-        expect(core.startSpan).toHaveBeenCalled();
+        expect(core.startSpan).toHaveBeenCalledWith(
+          expect.objectContaining({
+            name: 'event test.event1,test.event2',
+          }),
+          expect.any(Function),
+        );
+        expect(originalHandler).toHaveBeenCalled();
+      });
+
+      it('should wrap symbol array event handlers', async () => {
+        const decorated = wrappedOnEvent([Symbol('test.event1'), Symbol('test.event2')]);
+        decorated(mockTarget, 'testMethod', descriptor);
+
+        await descriptor.value();
+
+        expect(core.startSpan).toHaveBeenCalledWith(
+          expect.objectContaining({
+            name: 'event Symbol(test.event1),Symbol(test.event2)',
+          }),
+          expect.any(Function),
+        );
+        expect(originalHandler).toHaveBeenCalled();
+      });
+
+      it('should wrap mixed type array event handlers', async () => {
+        const decorated = wrappedOnEvent([Symbol('test.event1'), 'test.event2', Symbol('test.event3')]);
+        decorated(mockTarget, 'testMethod', descriptor);
+
+        await descriptor.value();
+
+        expect(core.startSpan).toHaveBeenCalledWith(
+          expect.objectContaining({
+            name: 'event Symbol(test.event1),test.event2,Symbol(test.event3)',
+          }),
+          expect.any(Function),
+        );
         expect(originalHandler).toHaveBeenCalled();
       });
 

packages/react-router/src/server/createSentryHandleRequest.tsx

@@ -53,6 +53,22 @@ export interface SentryHandleRequestOptions {
   botRegex?: RegExp;
 }
 
+type HandleRequestWithoutMiddleware = (
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  routerContext: EntryContext,
+  loadContext: AppLoadContext,
+) => Promise<unknown>;
+
+type HandleRequestWithMiddleware = (
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  routerContext: EntryContext,
+  loadContext: RouterContextProvider,
+) => Promise<unknown>;
+
 /**
  * A complete Sentry-instrumented handleRequest implementation that handles both
  * route parametrization and trace meta tag injection.
@@ -62,13 +78,7 @@ export interface SentryHandleRequestOptions {
  */
 export function createSentryHandleRequest(
   options: SentryHandleRequestOptions,
-): (
-  request: Request,
-  responseStatusCode: number,
-  responseHeaders: Headers,
-  routerContext: EntryContext,
-  loadContext: AppLoadContext | RouterContextProvider,
-) => Promise<unknown> {
+): HandleRequestWithoutMiddleware & HandleRequestWithMiddleware {
   const {
     streamTimeout = 10000,
     renderToPipeableStream,
@@ -135,5 +145,6 @@ export function createSentryHandleRequest(
   };
 
   // Wrap the handle request function for request parametrization
-  return wrapSentryHandleRequest(handleRequest);
+  return wrapSentryHandleRequest(handleRequest as HandleRequestWithoutMiddleware) as HandleRequestWithoutMiddleware &
+    HandleRequestWithMiddleware;
 }

packages/react-router/src/server/wrapSentryHandleRequest.ts

@@ -10,12 +10,20 @@ import {
 } from '@sentry/core';
 import type { AppLoadContext, EntryContext, RouterContextProvider } from 'react-router';
 
-type OriginalHandleRequest = (
+type OriginalHandleRequestWithoutMiddleware = (
   request: Request,
   responseStatusCode: number,
   responseHeaders: Headers,
   routerContext: EntryContext,
-  loadContext: AppLoadContext | RouterContextProvider,
+  loadContext: AppLoadContext,
+) => Promise<unknown>;
+
+type OriginalHandleRequestWithMiddleware = (
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  routerContext: EntryContext,
+  loadContext: RouterContextProvider,
 ) => Promise<unknown>;
 
 /**
@@ -24,7 +32,27 @@ type OriginalHandleRequest = (
  * @param originalHandle - The original handleRequest function to wrap
  * @returns A wrapped version of the handle request function with Sentry instrumentation
  */
-export function wrapSentryHandleRequest(originalHandle: OriginalHandleRequest): OriginalHandleRequest {
+export function wrapSentryHandleRequest(
+  originalHandle: OriginalHandleRequestWithoutMiddleware,
+): OriginalHandleRequestWithoutMiddleware;
+/**
+ * Wraps the original handleRequest function to add Sentry instrumentation.
+ *
+ * @param originalHandle - The original handleRequest function to wrap
+ * @returns A wrapped version of the handle request function with Sentry instrumentation
+ */
+export function wrapSentryHandleRequest(
+  originalHandle: OriginalHandleRequestWithMiddleware,
+): OriginalHandleRequestWithMiddleware;
+/**
+ * Wraps the original handleRequest function to add Sentry instrumentation.
+ *
+ * @param originalHandle - The original handleRequest function to wrap
+ * @returns A wrapped version of the handle request function with Sentry instrumentation
+ */
+export function wrapSentryHandleRequest(
+  originalHandle: OriginalHandleRequestWithoutMiddleware | OriginalHandleRequestWithMiddleware,
+): OriginalHandleRequestWithoutMiddleware | OriginalHandleRequestWithMiddleware {
   return async function sentryInstrumentedHandleRequest(
     request: Request,
     responseStatusCode: number,
@@ -57,10 +85,39 @@ export function wrapSentryHandleRequest(originalHandle: OriginalHandleRequest):
     }
 
     try {
-      return await originalHandle(request, responseStatusCode, responseHeaders, routerContext, loadContext);
+      // Type guard to call the correct overload based on loadContext type
+      if (isRouterContextProvider(loadContext)) {
+        // loadContext is RouterContextProvider
+        return await (originalHandle as OriginalHandleRequestWithMiddleware)(
+          request,
+          responseStatusCode,
+          responseHeaders,
+          routerContext,
+          loadContext,
+        );
+      } else {
+        // loadContext is AppLoadContext
+        return await (originalHandle as OriginalHandleRequestWithoutMiddleware)(
+          request,
+          responseStatusCode,
+          responseHeaders,
+          routerContext,
+          loadContext,
+        );
+      }
     } finally {
       await flushIfServerless();
     }
+
+    /**
+     * Helper type guard to determine if the context is a RouterContextProvider.
+     *
+     * @param ctx - The context to check
+     * @returns True if the context is a RouterContextProvider
+     */
+    function isRouterContextProvider(ctx: AppLoadContext | RouterContextProvider): ctx is RouterContextProvider {
+      return typeof (ctx as RouterContextProvider)?.get === 'function';
+    }
   };
 }