start span if there is none

Author: s1gr1d

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

@@ -50,6 +50,7 @@ test('Should record exceptions and transactions for faulty route handlers', asyn
 
   expect(routehandlerTransaction.contexts?.trace?.status).toBe('unknown_error');
   expect(routehandlerTransaction.contexts?.trace?.op).toBe('http.server');
+  expect(routehandlerTransaction.contexts?.trace?.origin).toBe('auto.function.nextjs');
 
   expect(routehandlerError.exception?.values?.[0].value).toBe('route-handler-error');
   // TODO: Uncomment once we update the scope transaction name on the server side

packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts

@@ -1,20 +1,62 @@
 import {
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SPAN_STATUS_ERROR,
   addTracingExtensions,
   captureException,
   getActiveSpan,
   getRootSpan,
   handleCallbackErrors,
   setHttpStatus,
+  startSpan,
   withIsolationScope,
 } from '@sentry/core';
+import type { Span } from '@sentry/types';
 import { winterCGHeadersToDict } from '@sentry/utils';
 import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavigationErrorUtils';
 import type { RouteHandlerContext } from './types';
 import { platformSupportsStreaming } from './utils/platformSupportsStreaming';
 import { flushQueue } from './utils/responseEnd';
 import { withIsolationScopeOrReuseFromRootSpan } from './utils/withIsolationScopeOrReuseFromRootSpan';
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function addSpanAttributes<F extends (...args: any[]) => any>(
+  originalFunction: F,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  thisArg: any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  args: any[],
+  rootSpan?: Span,
+): Promise<Response> {
+  const response: Response = await 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 if (isNotFoundNavigationError(error) && rootSpan) {
+        rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
+      } else {
+        captureException(error, {
+          mechanism: {
+            handled: false,
+          },
+        });
+      }
+    },
+  );
+
+  try {
+    if (rootSpan && response.status) {
+      setHttpStatus(rootSpan, response.status);
+    }
+  } catch {
+    // best effort - response may be undefined?
+  }
+
+  return response;
+}
+
 /**
  * Wraps a Next.js route handler with performance and error instrumentation.
  */
@@ -25,10 +67,10 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
 ): (...args: Parameters<F>) => ReturnType<F> extends Promise<unknown> ? ReturnType<F> : Promise<ReturnType<F>> {
   addTracingExtensions();
 
-  const { headers } = context;
+  const { method, parameterizedRoute, headers } = context;
 
   return new Proxy(routeHandler, {
-    apply: async (originalFunction, thisArg, args) => {
+    apply: (originalFunction, thisArg, args) => {
       return withIsolationScope(async isolationScope => {
         isolationScope.setSDKProcessingMetadata({
           request: {
@@ -40,33 +82,24 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
           const activeSpan = getActiveSpan();
           const rootSpan = activeSpan && getRootSpan(activeSpan);
 
-          const response: Response = await 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 if (isNotFoundNavigationError(error) && rootSpan) {
-                rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
-              } else {
-                captureException(error, {
-                  mechanism: {
-                    handled: false,
-                  },
-                });
-              }
-            },
-          );
-
-          try {
-            if (rootSpan && response.status) {
-              setHttpStatus(rootSpan, response.status);
-            }
-          } catch {
-            // best effort - response may be undefined?
+          if (rootSpan) {
+            return await addSpanAttributes<F>(originalFunction, thisArg, args, rootSpan);
+          } else {
+            /** As our own HTTP integration is disabled (src/server/index.ts) the rootSpan comes from Next.js.
+             * In case there is not root span, we start a new one. */
+            return await startSpan(
+              {
+                op: 'http.server',
+                name: `${method} ${parameterizedRoute}`,
+                forceTransaction: true,
+                attributes: {
+                  [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
+                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
+                },
+              },
+              async span => addSpanAttributes(originalFunction, thisArg, args, span),
+            );
           }
-
-          return response;
         } finally {
           if (!platformSupportsStreaming() || process.env.NEXT_RUNTIME === 'edge') {
             // 1. Edge transport requires manual flushing