Merge branch 'develop' into cg-next-manifest-turbopack

Author: chargome

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 @janpapenbrock. Thank you for your contribution!
+
 ## 9.38.0
 
 ### Important Changes

dev-packages/browser-integration-tests/suites/replay/logger/test.ts

@@ -21,7 +21,7 @@ sentryTest('should output logger messages', async ({ getLocalTestUrl, page }) =>
   await Promise.all([page.goto(url), reqPromise0]);
 
   expect(messages).toContain('Sentry Logger [log]: Integration installed: Replay');
-  expect(messages).toContain('Sentry Logger [info]: [Replay]  Creating new session');
-  expect(messages).toContain('Sentry Logger [info]: [Replay]  Starting replay in session mode');
-  expect(messages).toContain('Sentry Logger [info]: [Replay]  Using compression worker');
+  expect(messages).toContain('Sentry Logger [log]: [Replay]  Creating new session');
+  expect(messages).toContain('Sentry Logger [log]: [Replay]  Starting replay in session mode');
+  expect(messages).toContain('Sentry Logger [log]: [Replay]  Using compression worker');
 });

dev-packages/e2e-tests/run.ts

@@ -84,10 +84,10 @@ async function run(): Promise<void> {
       const cwd = tmpDirPath;
 
       console.log(`Building ${testAppPath} in ${tmpDirPath}...`);
-      await asyncExec('pnpm test:build', { env, cwd });
+      await asyncExec('volta run pnpm test:build', { env, cwd });
 
       console.log(`Testing ${testAppPath}...`);
-      await asyncExec('pnpm test:assert', { env, cwd });
+      await asyncExec('volta run pnpm test:assert', { env, cwd });
 
       // clean up (although this is tmp, still nice to do)
       await rm(tmpDirPath, { recursive: true });

dev-packages/e2e-tests/test-applications/nextjs-14/app/generation-functions/with-redirect/page.tsx

@@ -108,20 +108,3 @@ test('Should send a transaction and an error event for a faulty generateViewport
 
   expect(errorEvent.transaction).toBe('Page.generateViewport (/generation-functions)');
 });
-
-test('Should send a transaction event with correct status for a generateMetadata() function invocation with redirect()', async ({
-  page,
-}) => {
-  const testTitle = 'redirect-foobar';
-
-  const transactionPromise = waitForTransaction('nextjs-14', async transactionEvent => {
-    return (
-      transactionEvent.contexts?.trace?.data?.['http.target'] ===
-      `/generation-functions/with-redirect?metadataTitle=${testTitle}`
-    );
-  });
-
-  await page.goto(`/generation-functions/with-redirect?metadataTitle=${testTitle}`);
-
-  expect((await transactionPromise).contexts?.trace?.status).toBe('ok');
-});

dev-packages/e2e-tests/test-applications/nextjs-14/tests/generation-functions.test.ts

@@ -31,34 +31,34 @@ test('should create AI spans with correct attributes', async ({ page }) => {
 
   // First AI call - should have telemetry enabled and record inputs/outputs (sendDefaultPii: true)
   /* const firstPipelineSpan = aiPipelineSpans[0];
-  expect(firstPipelineSpan?.data?.['ai.model.id']).toBe('mock-model-id');
-  expect(firstPipelineSpan?.data?.['ai.model.provider']).toBe('mock-provider');
-  expect(firstPipelineSpan?.data?.['ai.prompt']).toContain('Where is the first span?');
+  expect(firstPipelineSpan?.data?.['vercel.ai.model.id']).toBe('mock-model-id');
+  expect(firstPipelineSpan?.data?.['vercel.ai.model.provider']).toBe('mock-provider');
+  expect(firstPipelineSpan?.data?.['vercel.ai.prompt']).toContain('Where is the first span?');
   expect(firstPipelineSpan?.data?.['gen_ai.response.text']).toBe('First span here!');
   expect(firstPipelineSpan?.data?.['gen_ai.usage.input_tokens']).toBe(10);
   expect(firstPipelineSpan?.data?.['gen_ai.usage.output_tokens']).toBe(20); */
 
   // Second AI call - explicitly enabled telemetry
   const secondPipelineSpan = aiPipelineSpans[0];
-  expect(secondPipelineSpan?.data?.['ai.prompt']).toContain('Where is the second span?');
+  expect(secondPipelineSpan?.data?.['vercel.ai.prompt']).toContain('Where is the second span?');
   expect(secondPipelineSpan?.data?.['gen_ai.response.text']).toContain('Second span here!');
 
   // Third AI call - with tool calls
   /*  const thirdPipelineSpan = aiPipelineSpans[2];
-  expect(thirdPipelineSpan?.data?.['ai.response.finishReason']).toBe('tool-calls');
+  expect(thirdPipelineSpan?.data?.['vercel.ai.response.finishReason']).toBe('tool-calls');
   expect(thirdPipelineSpan?.data?.['gen_ai.usage.input_tokens']).toBe(15);
   expect(thirdPipelineSpan?.data?.['gen_ai.usage.output_tokens']).toBe(25); */
 
   // Tool call span
   /*  const toolSpan = toolCallSpans[0];
-  expect(toolSpan?.data?.['ai.toolCall.name']).toBe('getWeather');
-  expect(toolSpan?.data?.['ai.toolCall.id']).toBe('call-1');
-  expect(toolSpan?.data?.['ai.toolCall.args']).toContain('San Francisco');
-  expect(toolSpan?.data?.['ai.toolCall.result']).toContain('Sunny, 72°F'); */
+  expect(toolSpan?.data?.['vercel.ai.toolCall.name']).toBe('getWeather');
+  expect(toolSpan?.data?.['vercel.ai.toolCall.id']).toBe('call-1');
+  expect(toolSpan?.data?.['vercel.ai.toolCall.args']).toContain('San Francisco');
+  expect(toolSpan?.data?.['vercel.ai.toolCall.result']).toContain('Sunny, 72°F'); */
 
   // Verify the fourth call was not captured (telemetry disabled)
   const promptsInSpans = spans
-    .map(span => span.data?.['ai.prompt'])
+    .map(span => span.data?.['vercel.ai.prompt'])
     .filter((prompt): prompt is string => prompt !== undefined);
   const hasDisabledPrompt = promptsInSpans.some(prompt => prompt.includes('Where is the third span?'));
   expect(hasDisabledPrompt).toBe(false);

dev-packages/e2e-tests/test-applications/nextjs-15/tests/ai-test.test.ts

@@ -5,5 +5,5 @@ export async function GET() {
 }
 
 export async function POST() {
-  return NextResponse.json({ name: 'John Doe' }, { status: 403 });
+  return NextResponse.json({ name: 'John Doe' }, { status: 400 });
 }

dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/route-handlers/[param]/route.ts

@@ -28,7 +28,7 @@ test('Should create a transaction for route handlers and correctly set span stat
 
   const routehandlerTransaction = await routehandlerTransactionPromise;
 
-  expect(routehandlerTransaction.contexts?.trace?.status).toBe('permission_denied');
+  expect(routehandlerTransaction.contexts?.trace?.status).toBe('invalid_argument');
   expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
 });
 

dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/route-handlers.test.ts

@@ -143,8 +143,8 @@ export const appRouter = t.router({
     .mutation(() => {
       throw new Error('I crashed in a trpc handler');
     }),
-  unauthorized: procedure.mutation(() => {
-    throw new TRPCError({ code: 'UNAUTHORIZED', cause: new Error('Unauthorized') });
+  badRequest: procedure.mutation(() => {
+    throw new TRPCError({ code: 'BAD_REQUEST', cause: new Error('Bad Request') });
   }),
 });
 

dev-packages/e2e-tests/test-applications/node-express/src/app.ts

@@ -109,12 +109,12 @@ test('Should record transaction and error for a trpc handler that returns a stat
   const transactionEventPromise = waitForTransaction('node-express', transactionEvent => {
     return (
       transactionEvent.transaction === 'POST /trpc' &&
-      !!transactionEvent.spans?.find(span => span.description === 'trpc/unauthorized')
+      !!transactionEvent.spans?.find(span => span.description === 'trpc/badRequest')
     );
   });
 
   const errorEventPromise = waitForError('node-express', errorEvent => {
-    return !!errorEvent?.exception?.values?.some(exception => exception.value?.includes('Unauthorized'));
+    return !!errorEvent?.exception?.values?.some(exception => exception.value?.includes('Bad Request'));
   });
 
   const trpcClient = createTRPCProxyClient<AppRouter>({
@@ -125,7 +125,7 @@ test('Should record transaction and error for a trpc handler that returns a stat
     ],
   });
 
-  await expect(trpcClient.unauthorized.mutate()).rejects.toBeDefined();
+  await expect(trpcClient.badRequest.mutate()).rejects.toBeDefined();
 
   await expect(transactionEventPromise).resolves.toBeDefined();
   await expect(errorEventPromise).resolves.toBeDefined();