fix(nextjs): Set parameterized transaction name for non-transaction events

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-exception/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureException(new Error('route-handler-capture-exception'));
+ return NextResponse.json({ message: 'Exception captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-message/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureMessage('route-handler-message');
+ return NextResponse.json({ message: 'Message captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/error/route.ts

@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ throw new Error('route-handler-error');
+}

dev-packages/e2e-tests/test-applications/nextjs-16/tests/route-handler.test.ts

@@ -1,5 +1,5 @@
 import test, { expect } from '@playwright/test';
-import { waitForTransaction } from '@sentry-internal/test-utils';
+import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
 
 test('Should create a transaction for node route handlers', async ({ request }) => {
  const routehandlerTransactionPromise = waitForTransaction('nextjs-16', async transactionEvent => {
@@ -37,3 +37,112 @@ test('Should create a transaction for edge route handlers', async ({ request })
  expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
  expect(routehandlerTransaction.contexts?.trace?.data?.['http.request.header.x_charly']).toBe('gomez');
 });
+
+test('Should report an error with a parameterized transaction name for a throwing route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-error') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/error' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ request.get('/route-handler/456/error').catch(() => {});
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Error should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+
+ // On turbopack (no wrapping loader), the error goes through onRequestError which sets nextjs context.
+ // On webpack, the wrapping loader's error handler fires first and captures without nextjs context.
+ // The SDK deduplicates by error identity, so only the first capture survives.
+ if (process.env.TEST_ENV === 'development') {
+ expect(errorEvent.contexts?.nextjs).toEqual({
+ route_type: 'route',
+ router_kind: 'App Router',
+ router_path: '/route-handler/[xoxo]/error',
+ request_path: '/route-handler/456/error',
+ });
+
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.function.nextjs.on_request_error',
+ });
+ }
+
+ // Transaction should have parameterized name and internal_error status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+ expect(transactionEvent.contexts?.trace?.status).toBe('internal_error');
+});
+
+test('Should set a parameterized transaction name on a captureMessage event in a route handler', async ({
+ request,
+}) => {
+ const messageEventPromise = waitForError('nextjs-16', event => {
+ return event?.message === 'route-handler-message';
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-message' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/789/capture-message');
+ expect(await response.json()).toStrictEqual({ message: 'Message captured' });
+
+ const messageEvent = await messageEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Message event should be part of the same trace as the transaction
+ expect(messageEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Message should carry the parameterized transaction name
+ expect(messageEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+
+ // Transaction should have parameterized name and ok status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});
+
+test('Should set a parameterized transaction name on a captureException event in a route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-capture-exception') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-exception' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/321/capture-exception');
+ expect(await response.json()).toStrictEqual({ message: 'Exception captured' });
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Manually captured exception should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+
+ // Transaction should have parameterized name and ok status (error was caught, not thrown)
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});

packages/nextjs/src/common/captureRequestError.ts

@@ -33,7 +33,7 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
  route_type: errorContext.routeType,
  });
 
- scope.setTransactionName(errorContext.routePath);
+ scope.setTransactionName(`${request.method} ${errorContext.routePath}`);
 
  captureException(error, {
  mechanism: {

packages/nextjs/src/server/handleOnSpanStart.ts

@@ -46,6 +46,14 @@ export function handleOnSpanStart(span: Span): void {
  // Preserving the original attribute despite internally not depending on it
  rootSpan.setAttribute(ATTR_NEXT_ROUTE, route);
 
+ // Update the isolation scope's transaction name so that non-transaction events
+ // (e.g. captureMessage, captureException) also get the parameterized route.
+ // eslint-disable-next-line deprecation/deprecation
+ const method = rootSpanAttributes?.[ATTR_HTTP_REQUEST_METHOD] || rootSpanAttributes?.[SEMATTRS_HTTP_METHOD];
+ if (typeof method === 'string') {
+ getIsolationScope().setTransactionName(`${method} ${route}`);
+ }
+
  // Check if this is a Vercel cron request and start a check-in
  maybeStartCronCheckIn(rootSpan, route);
  }

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-exception/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureException(new Error('route-handler-capture-exception'));
+ return NextResponse.json({ message: 'Exception captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-message/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureMessage('route-handler-message');
+ return NextResponse.json({ message: 'Message captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/error/route.ts

@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ throw new Error('route-handler-error');
+}

dev-packages/e2e-tests/test-applications/nextjs-16/tests/route-handler.test.ts

@@ -1,5 +1,5 @@
 import test, { expect } from '@playwright/test';
-import { waitForTransaction } from '@sentry-internal/test-utils';
+import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
 
 test('Should create a transaction for node route handlers', async ({ request }) => {
  const routehandlerTransactionPromise = waitForTransaction('nextjs-16', async transactionEvent => {
@@ -37,3 +37,112 @@ test('Should create a transaction for edge route handlers', async ({ request })
  expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
  expect(routehandlerTransaction.contexts?.trace?.data?.['http.request.header.x_charly']).toBe('gomez');
 });
+
+test('Should report an error with a parameterized transaction name for a throwing route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-error') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/error' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ request.get('/route-handler/456/error').catch(() => {});
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Error should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+
+ // On turbopack (no wrapping loader), the error goes through onRequestError which sets nextjs context.
+ // On webpack, the wrapping loader's error handler fires first and captures without nextjs context.
+ // The SDK deduplicates by error identity, so only the first capture survives.
+ if (process.env.TEST_ENV === 'development') {
+ expect(errorEvent.contexts?.nextjs).toEqual({
+ route_type: 'route',
+ router_kind: 'App Router',
+ router_path: '/route-handler/[xoxo]/error',
+ request_path: '/route-handler/456/error',
+ });
+
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.function.nextjs.on_request_error',
+ });
+ }
+
+ // Transaction should have parameterized name and internal_error status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+ expect(transactionEvent.contexts?.trace?.status).toBe('internal_error');
+});
+
+test('Should set a parameterized transaction name on a captureMessage event in a route handler', async ({
+ request,
+}) => {
+ const messageEventPromise = waitForError('nextjs-16', event => {
+ return event?.message === 'route-handler-message';
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-message' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/789/capture-message');
+ expect(await response.json()).toStrictEqual({ message: 'Message captured' });
+
+ const messageEvent = await messageEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Message event should be part of the same trace as the transaction
+ expect(messageEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Message should carry the parameterized transaction name
+ expect(messageEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+
+ // Transaction should have parameterized name and ok status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});
+
+test('Should set a parameterized transaction name on a captureException event in a route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-capture-exception') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-exception' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/321/capture-exception');
+ expect(await response.json()).toStrictEqual({ message: 'Exception captured' });
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Manually captured exception should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+
+ // Transaction should have parameterized name and ok status (error was caught, not thrown)
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});

packages/nextjs/src/common/captureRequestError.ts

@@ -33,7 +33,7 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
  route_type: errorContext.routeType,
  });
 
- scope.setTransactionName(errorContext.routePath);
+ scope.setTransactionName(`${request.method} ${errorContext.routePath}`);
 
  captureException(error, {
  mechanism: {

packages/nextjs/src/server/handleOnSpanStart.ts

@@ -46,6 +46,14 @@ export function handleOnSpanStart(span: Span): void {
  // Preserving the original attribute despite internally not depending on it
  rootSpan.setAttribute(ATTR_NEXT_ROUTE, route);
 
+ // Update the isolation scope's transaction name so that non-transaction events
+ // (e.g. captureMessage, captureException) also get the parameterized route.
+ // eslint-disable-next-line deprecation/deprecation
+ const method = rootSpanAttributes?.[ATTR_HTTP_REQUEST_METHOD] || rootSpanAttributes?.[SEMATTRS_HTTP_METHOD];
+ if (typeof method === 'string') {
+ getIsolationScope().setTransactionName(`${method} ${route}`);
+ }
+
  // Check if this is a Vercel cron request and start a check-in
  maybeStartCronCheckIn(rootSpan, route);
  }

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-exception/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureException(new Error('route-handler-capture-exception'));
+ return NextResponse.json({ message: 'Exception captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-message/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureMessage('route-handler-message');
+ return NextResponse.json({ message: 'Message captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/error/route.ts

@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ throw new Error('route-handler-error');
+}

dev-packages/e2e-tests/test-applications/nextjs-16/tests/route-handler.test.ts

@@ -1,5 +1,5 @@
 import test, { expect } from '@playwright/test';
-import { waitForTransaction } from '@sentry-internal/test-utils';
+import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
 
 test('Should create a transaction for node route handlers', async ({ request }) => {
  const routehandlerTransactionPromise = waitForTransaction('nextjs-16', async transactionEvent => {
@@ -37,3 +37,112 @@ test('Should create a transaction for edge route handlers', async ({ request })
  expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
  expect(routehandlerTransaction.contexts?.trace?.data?.['http.request.header.x_charly']).toBe('gomez');
 });
+
+test('Should report an error with a parameterized transaction name for a throwing route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-error') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/error' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ request.get('/route-handler/456/error').catch(() => {});
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Error should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+
+ // On turbopack (no wrapping loader), the error goes through onRequestError which sets nextjs context.
+ // On webpack, the wrapping loader's error handler fires first and captures without nextjs context.
+ // The SDK deduplicates by error identity, so only the first capture survives.
+ if (process.env.TEST_ENV === 'development') {
+ expect(errorEvent.contexts?.nextjs).toEqual({
+ route_type: 'route',
+ router_kind: 'App Router',
+ router_path: '/route-handler/[xoxo]/error',
+ request_path: '/route-handler/456/error',
+ });
+
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.function.nextjs.on_request_error',
+ });
+ }
+
+ // Transaction should have parameterized name and internal_error status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+ expect(transactionEvent.contexts?.trace?.status).toBe('internal_error');
+});
+
+test('Should set a parameterized transaction name on a captureMessage event in a route handler', async ({
+ request,
+}) => {
+ const messageEventPromise = waitForError('nextjs-16', event => {
+ return event?.message === 'route-handler-message';
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-message' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/789/capture-message');
+ expect(await response.json()).toStrictEqual({ message: 'Message captured' });
+
+ const messageEvent = await messageEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Message event should be part of the same trace as the transaction
+ expect(messageEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Message should carry the parameterized transaction name
+ expect(messageEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+
+ // Transaction should have parameterized name and ok status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});
+
+test('Should set a parameterized transaction name on a captureException event in a route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-capture-exception') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-exception' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/321/capture-exception');
+ expect(await response.json()).toStrictEqual({ message: 'Exception captured' });
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Manually captured exception should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+
+ // Transaction should have parameterized name and ok status (error was caught, not thrown)
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});

packages/nextjs/src/common/captureRequestError.ts

@@ -33,7 +33,7 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
  route_type: errorContext.routeType,
  });
 
- scope.setTransactionName(errorContext.routePath);
+ scope.setTransactionName(`${request.method} ${errorContext.routePath}`);
 
  captureException(error, {
  mechanism: {

packages/nextjs/src/server/handleOnSpanStart.ts

@@ -46,6 +46,14 @@ export function handleOnSpanStart(span: Span): void {
  // Preserving the original attribute despite internally not depending on it
  rootSpan.setAttribute(ATTR_NEXT_ROUTE, route);
 
+ // Update the isolation scope's transaction name so that non-transaction events
+ // (e.g. captureMessage, captureException) also get the parameterized route.
+ // eslint-disable-next-line deprecation/deprecation
+ const method = rootSpanAttributes?.[ATTR_HTTP_REQUEST_METHOD] || rootSpanAttributes?.[SEMATTRS_HTTP_METHOD];
+ if (typeof method === 'string') {
+ getIsolationScope().setTransactionName(`${method} ${route}`);
+ }
+
  // Check if this is a Vercel cron request and start a check-in
  maybeStartCronCheckIn(rootSpan, route);
  }

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-exception/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureException(new Error('route-handler-capture-exception'));
+ return NextResponse.json({ message: 'Exception captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-message/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureMessage('route-handler-message');
+ return NextResponse.json({ message: 'Message captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/error/route.ts

@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ throw new Error('route-handler-error');
+}

dev-packages/e2e-tests/test-applications/nextjs-16/tests/route-handler.test.ts

@@ -1,5 +1,5 @@
 import test, { expect } from '@playwright/test';
-import { waitForTransaction } from '@sentry-internal/test-utils';
+import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
 
 test('Should create a transaction for node route handlers', async ({ request }) => {
  const routehandlerTransactionPromise = waitForTransaction('nextjs-16', async transactionEvent => {
@@ -37,3 +37,112 @@ test('Should create a transaction for edge route handlers', async ({ request })
  expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
  expect(routehandlerTransaction.contexts?.trace?.data?.['http.request.header.x_charly']).toBe('gomez');
 });
+
+test('Should report an error with a parameterized transaction name for a throwing route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-error') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/error' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ request.get('/route-handler/456/error').catch(() => {});
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Error should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+
+ // On turbopack (no wrapping loader), the error goes through onRequestError which sets nextjs context.
+ // On webpack, the wrapping loader's error handler fires first and captures without nextjs context.
+ // The SDK deduplicates by error identity, so only the first capture survives.
+ if (process.env.TEST_ENV === 'development') {
+ expect(errorEvent.contexts?.nextjs).toEqual({
+ route_type: 'route',
+ router_kind: 'App Router',
+ router_path: '/route-handler/[xoxo]/error',
+ request_path: '/route-handler/456/error',
+ });
+
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.function.nextjs.on_request_error',
+ });
+ }
+
+ // Transaction should have parameterized name and internal_error status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+ expect(transactionEvent.contexts?.trace?.status).toBe('internal_error');
+});
+
+test('Should set a parameterized transaction name on a captureMessage event in a route handler', async ({
+ request,
+}) => {
+ const messageEventPromise = waitForError('nextjs-16', event => {
+ return event?.message === 'route-handler-message';
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-message' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/789/capture-message');
+ expect(await response.json()).toStrictEqual({ message: 'Message captured' });
+
+ const messageEvent = await messageEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Message event should be part of the same trace as the transaction
+ expect(messageEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Message should carry the parameterized transaction name
+ expect(messageEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+
+ // Transaction should have parameterized name and ok status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});
+
+test('Should set a parameterized transaction name on a captureException event in a route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-capture-exception') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-exception' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/321/capture-exception');
+ expect(await response.json()).toStrictEqual({ message: 'Exception captured' });
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Manually captured exception should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+
+ // Transaction should have parameterized name and ok status (error was caught, not thrown)
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});

packages/nextjs/src/common/captureRequestError.ts

@@ -33,7 +33,7 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
  route_type: errorContext.routeType,
  });
 
- scope.setTransactionName(errorContext.routePath);
+ scope.setTransactionName(`${request.method} ${errorContext.routePath}`);
 
  captureException(error, {
  mechanism: {

packages/nextjs/src/server/handleOnSpanStart.ts

@@ -46,6 +46,14 @@ export function handleOnSpanStart(span: Span): void {
  // Preserving the original attribute despite internally not depending on it
  rootSpan.setAttribute(ATTR_NEXT_ROUTE, route);
 
+ // Update the isolation scope's transaction name so that non-transaction events
+ // (e.g. captureMessage, captureException) also get the parameterized route.
+ // eslint-disable-next-line deprecation/deprecation
+ const method = rootSpanAttributes?.[ATTR_HTTP_REQUEST_METHOD] || rootSpanAttributes?.[SEMATTRS_HTTP_METHOD];
+ if (typeof method === 'string') {
+ getIsolationScope().setTransactionName(`${method} ${route}`);
+ }
+
  // Check if this is a Vercel cron request and start a check-in
  maybeStartCronCheckIn(rootSpan, route);
  }

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-exception/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureException(new Error('route-handler-capture-exception'));
+ return NextResponse.json({ message: 'Exception captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-message/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureMessage('route-handler-message');
+ return NextResponse.json({ message: 'Message captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/error/route.ts

@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ throw new Error('route-handler-error');
+}

dev-packages/e2e-tests/test-applications/nextjs-16/tests/route-handler.test.ts

@@ -1,5 +1,5 @@
 import test, { expect } from '@playwright/test';
-import { waitForTransaction } from '@sentry-internal/test-utils';
+import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
 
 test('Should create a transaction for node route handlers', async ({ request }) => {
  const routehandlerTransactionPromise = waitForTransaction('nextjs-16', async transactionEvent => {
@@ -37,3 +37,112 @@ test('Should create a transaction for edge route handlers', async ({ request })
  expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
  expect(routehandlerTransaction.contexts?.trace?.data?.['http.request.header.x_charly']).toBe('gomez');
 });
+
+test('Should report an error with a parameterized transaction name for a throwing route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-error') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/error' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ request.get('/route-handler/456/error').catch(() => {});
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Error should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+
+ // On turbopack (no wrapping loader), the error goes through onRequestError which sets nextjs context.
+ // On webpack, the wrapping loader's error handler fires first and captures without nextjs context.
+ // The SDK deduplicates by error identity, so only the first capture survives.
+ if (process.env.TEST_ENV === 'development') {
+ expect(errorEvent.contexts?.nextjs).toEqual({
+ route_type: 'route',
+ router_kind: 'App Router',
+ router_path: '/route-handler/[xoxo]/error',
+ request_path: '/route-handler/456/error',
+ });
+
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.function.nextjs.on_request_error',
+ });
+ }
+
+ // Transaction should have parameterized name and internal_error status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+ expect(transactionEvent.contexts?.trace?.status).toBe('internal_error');
+});
+
+test('Should set a parameterized transaction name on a captureMessage event in a route handler', async ({
+ request,
+}) => {
+ const messageEventPromise = waitForError('nextjs-16', event => {
+ return event?.message === 'route-handler-message';
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-message' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/789/capture-message');
+ expect(await response.json()).toStrictEqual({ message: 'Message captured' });
+
+ const messageEvent = await messageEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Message event should be part of the same trace as the transaction
+ expect(messageEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Message should carry the parameterized transaction name
+ expect(messageEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+
+ // Transaction should have parameterized name and ok status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});
+
+test('Should set a parameterized transaction name on a captureException event in a route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-capture-exception') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-exception' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/321/capture-exception');
+ expect(await response.json()).toStrictEqual({ message: 'Exception captured' });
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Manually captured exception should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+
+ // Transaction should have parameterized name and ok status (error was caught, not thrown)
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});

packages/nextjs/src/common/captureRequestError.ts

@@ -33,7 +33,7 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
  route_type: errorContext.routeType,
  });
 
- scope.setTransactionName(errorContext.routePath);
+ scope.setTransactionName(`${request.method} ${errorContext.routePath}`);
 
  captureException(error, {
  mechanism: {

packages/nextjs/src/server/handleOnSpanStart.ts

@@ -46,6 +46,14 @@ export function handleOnSpanStart(span: Span): void {
  // Preserving the original attribute despite internally not depending on it
  rootSpan.setAttribute(ATTR_NEXT_ROUTE, route);
 
+ // Update the isolation scope's transaction name so that non-transaction events
+ // (e.g. captureMessage, captureException) also get the parameterized route.
+ // eslint-disable-next-line deprecation/deprecation
+ const method = rootSpanAttributes?.[ATTR_HTTP_REQUEST_METHOD] || rootSpanAttributes?.[SEMATTRS_HTTP_METHOD];
+ if (typeof method === 'string') {
+ getIsolationScope().setTransactionName(`${method} ${route}`);
+ }
+
  // Check if this is a Vercel cron request and start a check-in
  maybeStartCronCheckIn(rootSpan, route);
  }

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-exception/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureException(new Error('route-handler-capture-exception'));
+ return NextResponse.json({ message: 'Exception captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-message/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureMessage('route-handler-message');
+ return NextResponse.json({ message: 'Message captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/error/route.ts

@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ throw new Error('route-handler-error');
+}

dev-packages/e2e-tests/test-applications/nextjs-16/tests/route-handler.test.ts

@@ -1,5 +1,5 @@
 import test, { expect } from '@playwright/test';
-import { waitForTransaction } from '@sentry-internal/test-utils';
+import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
 
 test('Should create a transaction for node route handlers', async ({ request }) => {
  const routehandlerTransactionPromise = waitForTransaction('nextjs-16', async transactionEvent => {
@@ -37,3 +37,112 @@ test('Should create a transaction for edge route handlers', async ({ request })
  expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
  expect(routehandlerTransaction.contexts?.trace?.data?.['http.request.header.x_charly']).toBe('gomez');
 });
+
+test('Should report an error with a parameterized transaction name for a throwing route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-error') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/error' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ request.get('/route-handler/456/error').catch(() => {});
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Error should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+
+ // On turbopack (no wrapping loader), the error goes through onRequestError which sets nextjs context.
+ // On webpack, the wrapping loader's error handler fires first and captures without nextjs context.
+ // The SDK deduplicates by error identity, so only the first capture survives.
+ if (process.env.TEST_ENV === 'development') {
+ expect(errorEvent.contexts?.nextjs).toEqual({
+ route_type: 'route',
+ router_kind: 'App Router',
+ router_path: '/route-handler/[xoxo]/error',
+ request_path: '/route-handler/456/error',
+ });
+
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.function.nextjs.on_request_error',
+ });
+ }
+
+ // Transaction should have parameterized name and internal_error status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+ expect(transactionEvent.contexts?.trace?.status).toBe('internal_error');
+});
+
+test('Should set a parameterized transaction name on a captureMessage event in a route handler', async ({
+ request,
+}) => {
+ const messageEventPromise = waitForError('nextjs-16', event => {
+ return event?.message === 'route-handler-message';
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-message' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/789/capture-message');
+ expect(await response.json()).toStrictEqual({ message: 'Message captured' });
+
+ const messageEvent = await messageEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Message event should be part of the same trace as the transaction
+ expect(messageEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Message should carry the parameterized transaction name
+ expect(messageEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+
+ // Transaction should have parameterized name and ok status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});
+
+test('Should set a parameterized transaction name on a captureException event in a route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-capture-exception') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-exception' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/321/capture-exception');
+ expect(await response.json()).toStrictEqual({ message: 'Exception captured' });
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Manually captured exception should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+
+ // Transaction should have parameterized name and ok status (error was caught, not thrown)
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});

packages/nextjs/src/common/captureRequestError.ts

@@ -33,7 +33,7 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
  route_type: errorContext.routeType,
  });
 
- scope.setTransactionName(errorContext.routePath);
+ scope.setTransactionName(`${request.method} ${errorContext.routePath}`);
 
  captureException(error, {
  mechanism: {

packages/nextjs/src/server/handleOnSpanStart.ts

@@ -46,6 +46,14 @@ export function handleOnSpanStart(span: Span): void {
  // Preserving the original attribute despite internally not depending on it
  rootSpan.setAttribute(ATTR_NEXT_ROUTE, route);
 
+ // Update the isolation scope's transaction name so that non-transaction events
+ // (e.g. captureMessage, captureException) also get the parameterized route.
+ // eslint-disable-next-line deprecation/deprecation
+ const method = rootSpanAttributes?.[ATTR_HTTP_REQUEST_METHOD] || rootSpanAttributes?.[SEMATTRS_HTTP_METHOD];
+ if (typeof method === 'string') {
+ getIsolationScope().setTransactionName(`${method} ${route}`);
+ }
+
  // Check if this is a Vercel cron request and start a check-in
  maybeStartCronCheckIn(rootSpan, route);
  }

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-exception/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureException(new Error('route-handler-capture-exception'));
+ return NextResponse.json({ message: 'Exception captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-message/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureMessage('route-handler-message');
+ return NextResponse.json({ message: 'Message captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/error/route.ts

@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ throw new Error('route-handler-error');
+}

dev-packages/e2e-tests/test-applications/nextjs-16/tests/route-handler.test.ts

@@ -1,5 +1,5 @@
 import test, { expect } from '@playwright/test';
-import { waitForTransaction } from '@sentry-internal/test-utils';
+import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
 
 test('Should create a transaction for node route handlers', async ({ request }) => {
  const routehandlerTransactionPromise = waitForTransaction('nextjs-16', async transactionEvent => {
@@ -37,3 +37,112 @@ test('Should create a transaction for edge route handlers', async ({ request })
  expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
  expect(routehandlerTransaction.contexts?.trace?.data?.['http.request.header.x_charly']).toBe('gomez');
 });
+
+test('Should report an error with a parameterized transaction name for a throwing route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-error') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/error' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ request.get('/route-handler/456/error').catch(() => {});
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Error should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+
+ // On turbopack (no wrapping loader), the error goes through onRequestError which sets nextjs context.
+ // On webpack, the wrapping loader's error handler fires first and captures without nextjs context.
+ // The SDK deduplicates by error identity, so only the first capture survives.
+ if (process.env.TEST_ENV === 'development') {
+ expect(errorEvent.contexts?.nextjs).toEqual({
+ route_type: 'route',
+ router_kind: 'App Router',
+ router_path: '/route-handler/[xoxo]/error',
+ request_path: '/route-handler/456/error',
+ });
+
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.function.nextjs.on_request_error',
+ });
+ }
+
+ // Transaction should have parameterized name and internal_error status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+ expect(transactionEvent.contexts?.trace?.status).toBe('internal_error');
+});
+
+test('Should set a parameterized transaction name on a captureMessage event in a route handler', async ({
+ request,
+}) => {
+ const messageEventPromise = waitForError('nextjs-16', event => {
+ return event?.message === 'route-handler-message';
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-message' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/789/capture-message');
+ expect(await response.json()).toStrictEqual({ message: 'Message captured' });
+
+ const messageEvent = await messageEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Message event should be part of the same trace as the transaction
+ expect(messageEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Message should carry the parameterized transaction name
+ expect(messageEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+
+ // Transaction should have parameterized name and ok status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});
+
+test('Should set a parameterized transaction name on a captureException event in a route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-capture-exception') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-exception' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/321/capture-exception');
+ expect(await response.json()).toStrictEqual({ message: 'Exception captured' });
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Manually captured exception should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+
+ // Transaction should have parameterized name and ok status (error was caught, not thrown)
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});

packages/nextjs/src/common/captureRequestError.ts

@@ -33,7 +33,7 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
  route_type: errorContext.routeType,
  });
 
- scope.setTransactionName(errorContext.routePath);
+ scope.setTransactionName(`${request.method} ${errorContext.routePath}`);
 
  captureException(error, {
  mechanism: {

packages/nextjs/src/server/handleOnSpanStart.ts

@@ -46,6 +46,14 @@ export function handleOnSpanStart(span: Span): void {
  // Preserving the original attribute despite internally not depending on it
  rootSpan.setAttribute(ATTR_NEXT_ROUTE, route);
 
+ // Update the isolation scope's transaction name so that non-transaction events
+ // (e.g. captureMessage, captureException) also get the parameterized route.
+ // eslint-disable-next-line deprecation/deprecation
+ const method = rootSpanAttributes?.[ATTR_HTTP_REQUEST_METHOD] || rootSpanAttributes?.[SEMATTRS_HTTP_METHOD];
+ if (typeof method === 'string') {
+ getIsolationScope().setTransactionName(`${method} ${route}`);
+ }
+
  // Check if this is a Vercel cron request and start a check-in
  maybeStartCronCheckIn(rootSpan, route);
  }

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-exception/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureException(new Error('route-handler-capture-exception'));
+ return NextResponse.json({ message: 'Exception captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/capture-message/route.ts

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ Sentry.captureMessage('route-handler-message');
+ return NextResponse.json({ message: 'Message captured' });
+}

dev-packages/e2e-tests/test-applications/nextjs-16/app/route-handler/[xoxo]/error/route.ts

@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+ throw new Error('route-handler-error');
+}

dev-packages/e2e-tests/test-applications/nextjs-16/tests/route-handler.test.ts

@@ -1,5 +1,5 @@
 import test, { expect } from '@playwright/test';
-import { waitForTransaction } from '@sentry-internal/test-utils';
+import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
 
 test('Should create a transaction for node route handlers', async ({ request }) => {
  const routehandlerTransactionPromise = waitForTransaction('nextjs-16', async transactionEvent => {
@@ -37,3 +37,112 @@ test('Should create a transaction for edge route handlers', async ({ request })
  expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
  expect(routehandlerTransaction.contexts?.trace?.data?.['http.request.header.x_charly']).toBe('gomez');
 });
+
+test('Should report an error with a parameterized transaction name for a throwing route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-error') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/error' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ request.get('/route-handler/456/error').catch(() => {});
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Error should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+
+ // On turbopack (no wrapping loader), the error goes through onRequestError which sets nextjs context.
+ // On webpack, the wrapping loader's error handler fires first and captures without nextjs context.
+ // The SDK deduplicates by error identity, so only the first capture survives.
+ if (process.env.TEST_ENV === 'development') {
+ expect(errorEvent.contexts?.nextjs).toEqual({
+ route_type: 'route',
+ router_kind: 'App Router',
+ router_path: '/route-handler/[xoxo]/error',
+ request_path: '/route-handler/456/error',
+ });
+
+ expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+ handled: false,
+ type: 'auto.function.nextjs.on_request_error',
+ });
+ }
+
+ // Transaction should have parameterized name and internal_error status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/error');
+ expect(transactionEvent.contexts?.trace?.status).toBe('internal_error');
+});
+
+test('Should set a parameterized transaction name on a captureMessage event in a route handler', async ({
+ request,
+}) => {
+ const messageEventPromise = waitForError('nextjs-16', event => {
+ return event?.message === 'route-handler-message';
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-message' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/789/capture-message');
+ expect(await response.json()).toStrictEqual({ message: 'Message captured' });
+
+ const messageEvent = await messageEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Message event should be part of the same trace as the transaction
+ expect(messageEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Message should carry the parameterized transaction name
+ expect(messageEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+
+ // Transaction should have parameterized name and ok status
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-message');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});
+
+test('Should set a parameterized transaction name on a captureException event in a route handler', async ({
+ request,
+}) => {
+ const errorEventPromise = waitForError('nextjs-16', errorEvent => {
+ return errorEvent?.exception?.values?.some(value => value.value === 'route-handler-capture-exception') ?? false;
+ });
+
+ const transactionEventPromise = waitForTransaction('nextjs-16', transactionEvent => {
+ return (
+ transactionEvent?.transaction === 'GET /route-handler/[xoxo]/capture-exception' &&
+ transactionEvent?.contexts?.trace?.op === 'http.server'
+ );
+ });
+
+ const response = await request.get('/route-handler/321/capture-exception');
+ expect(await response.json()).toStrictEqual({ message: 'Exception captured' });
+
+ const errorEvent = await errorEventPromise;
+ const transactionEvent = await transactionEventPromise;
+
+ // Error event should be part of the same trace as the transaction
+ expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
+
+ // Manually captured exception should carry the parameterized transaction name
+ expect(errorEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+
+ // Transaction should have parameterized name and ok status (error was caught, not thrown)
+ expect(transactionEvent.transaction).toBe('GET /route-handler/[xoxo]/capture-exception');
+ expect(transactionEvent.contexts?.trace?.status).toBe('ok');
+});

packages/nextjs/src/common/captureRequestError.ts

@@ -33,7 +33,7 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
  route_type: errorContext.routeType,
  });
 
- scope.setTransactionName(errorContext.routePath);
+ scope.setTransactionName(`${request.method} ${errorContext.routePath}`);
 
  captureException(error, {
  mechanism: {

packages/nextjs/src/server/handleOnSpanStart.ts

@@ -46,6 +46,14 @@ export function handleOnSpanStart(span: Span): void {
  // Preserving the original attribute despite internally not depending on it
  rootSpan.setAttribute(ATTR_NEXT_ROUTE, route);
 
+ // Update the isolation scope's transaction name so that non-transaction events
+ // (e.g. captureMessage, captureException) also get the parameterized route.
+ // eslint-disable-next-line deprecation/deprecation
+ const method = rootSpanAttributes?.[ATTR_HTTP_REQUEST_METHOD] || rootSpanAttributes?.[SEMATTRS_HTTP_METHOD];
+ if (typeof method === 'string') {
+ getIsolationScope().setTransactionName(`${method} ${route}`);
+ }
+
  // Check if this is a Vercel cron request and start a check-in
  maybeStartCronCheckIn(rootSpan, route);
  }