return of the scopes

Author: chargome

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

@@ -54,9 +54,9 @@ test('Should record exceptions and transactions for faulty route handlers', asyn
   expect(routehandlerError.tags?.['my-isolated-tag']).toBe(true);
   expect(routehandlerError.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
 
-  expect(routehandlerTransaction.contexts?.trace?.status).toBe('unknown_error');
+  expect(routehandlerTransaction.contexts?.trace?.status).toBe('internal_error');
   expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
-  expect(routehandlerTransaction.contexts?.trace?.origin).toBe('auto.function.nextjs');
+  expect(routehandlerTransaction.contexts?.trace?.origin).toBe('auto');
 
   expect(routehandlerError.exception?.values?.[0].value).toBe('route-handler-error');
 

packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts

@@ -1,8 +1,21 @@
-import { Scope, getActiveSpan, getCapturedScopesOnSpan, getRootSpan, setCapturedScopesOnSpan } from '@sentry/core';
+import {
+  Scope,
+  captureException,
+  getActiveSpan,
+  getCapturedScopesOnSpan,
+  getRootSpan,
+  handleCallbackErrors,
+  setCapturedScopesOnSpan,
+  withIsolationScope,
+  withScope,
+} from '@sentry/core';
 
 import type { RouteHandlerContext } from './types';
 
-import { commonObjectToIsolationScope } from './utils/tracingUtils';
+import { propagationContextFromHeaders, winterCGHeadersToDict } from '@sentry/utils';
+
+import { isRedirectNavigationError } from './nextNavigationErrorUtils';
+import { commonObjectToIsolationScope, commonObjectToPropagationContext } from './utils/tracingUtils';
 
 /**
  * Wraps a Next.js App Router Route handler with Sentry error and performance instrumentation.
@@ -14,24 +27,56 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
   routeHandler: F,
   context: RouteHandlerContext,
 ): (...args: Parameters<F>) => ReturnType<F> extends Promise<unknown> ? ReturnType<F> : Promise<ReturnType<F>> {
-  const { headers } = context;
+  const { method, parameterizedRoute, headers } = context;
 
   return new Proxy(routeHandler, {
-    apply: (originalFunction, thisArg, args) => {
+    apply: async (originalFunction, thisArg, args) => {
       const isolationScope = commonObjectToIsolationScope(headers);
 
+      const completeHeadersDict: Record<string, string> = headers ? winterCGHeadersToDict(headers) : {};
+
+      isolationScope.setSDKProcessingMetadata({
+        request: {
+          headers: completeHeadersDict,
+        },
+      });
+
+      const incomingPropagationContext = propagationContextFromHeaders(
+        completeHeadersDict['sentry-trace'],
+        completeHeadersDict['baggage'],
+      );
+
+      const propagationContext = commonObjectToPropagationContext(headers, incomingPropagationContext);
+
       const activeSpan = getActiveSpan();
       if (activeSpan) {
         const rootSpan = getRootSpan(activeSpan);
+        rootSpan.setAttribute('sentry.route_handler', true);
         const { scope } = getCapturedScopesOnSpan(rootSpan);
         setCapturedScopesOnSpan(rootSpan, scope ?? new Scope(), isolationScope);
-
-        // We mark the root span as an app route handler span so we can allow-list it in our span processor
-        // that would normally filter out all Next.js transactions/spans
-        rootSpan.setAttribute('sentry.route_handler', true);
       }
 
-      return originalFunction.apply(thisArg, args);
+      return withIsolationScope(isolationScope, () => {
+        return withScope(scope => {
+          scope.setTransactionName(`${method} ${parameterizedRoute}`);
+          scope.setPropagationContext(propagationContext);
+          return handleCallbackErrors(
+            () => originalFunction.apply(thisArg, args),
+            error => {
+              // Next.js throws errors when calling `redirect()`. We don't wanna report these.
+              if (isRedirectNavigationError(error)) {
+                // Don't do anything
+              } else {
+                captureException(error, {
+                  mechanism: {
+                    handled: false,
+                  },
+                });
+              }
+            },
+          );
+        });
+      });
     },
   });
 }

packages/nextjs/src/server/index.ts

@@ -196,7 +196,10 @@ export function init(options: NodeOptions): NodeClient | undefined {
     // We want to rename these spans because they look like "GET /path/to/route" and we already emit spans that look
     // like this with our own http instrumentation.
     if (spanAttributes?.['next.span_type'] === 'BaseServer.handleRequest') {
-      span.updateName('next server handler'); // This is all lowercase because the spans that Next.js emits by itself generally look like this.
+      const rootSpan = getRootSpan(span);
+      if (span !== rootSpan) {
+        span.updateName('next server handler'); // This is all lowercase because the spans that Next.js emits by itself generally look like this.
+      }
     }
   });
 
@@ -307,16 +310,16 @@ export function init(options: NodeOptions): NodeClient | undefined {
         }
 
         // Enhance route handler transactions
-        if (
-          event.type === 'transaction' &&
-          event.transaction?.match(/^(GET|HEAD|POST|PUT|DELETE|CONNECT|OPTIONS|TRACE|PATCH) .*\/route$/) &&
-          event.contexts?.trace?.data?.['sentry.route_handler'] === true &&
-          !event.contexts.trace.op
-        ) {
+        if (event.type === 'transaction' && event.contexts?.trace?.data?.['sentry.route_handler'] === true) {
           event.contexts.trace.data = event.contexts.trace.data || {};
           event.contexts.trace.data[SEMANTIC_ATTRIBUTE_SENTRY_OP] = 'http.server';
           event.contexts.trace.op = 'http.server';
-          event.transaction = event.transaction.replace(/\/route$/, '');
+          if (typeof event.contexts.trace.data[ATTR_HTTP_ROUTE] === 'string') {
+            // eslint-disable-next-line deprecation/deprecation
+            event.transaction = `${event.contexts.trace.data[SEMATTRS_HTTP_METHOD]} ${event.contexts.trace.data[
+              ATTR_HTTP_ROUTE
+            ].replace(/\/route$/, '')}`;
+          }
         }
 
         return event;