add startOrUpdateSpan function

Author: s1gr1d

dev-packages/e2e-tests/test-applications/nextjs-14/tests/request-instrumentation.test.ts

@@ -24,7 +24,8 @@ test('Should send a transaction with a fetch span', async ({ page }) => {
       data: expect.objectContaining({
         'http.method': 'GET',
         'sentry.op': 'http.client',
-        'sentry.origin': 'auto.http.otel.http',
+        // todo: without the HTTP integration in the Next.js SDK, this is set to 'manual' -> we could rename this to be more specific
+        'sentry.origin': 'manual',
       }),
       description: 'GET http://example.com/',
     }),

packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts

@@ -1,4 +1,5 @@
 import {
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SPAN_STATUS_ERROR,
@@ -18,42 +19,38 @@ import type { RouteHandlerContext } from './types';
 import { platformSupportsStreaming } from './utils/platformSupportsStreaming';
 import { flushQueue } from './utils/responseEnd';
 
-// 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,
+/** 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 span. */
+function startOrUpdateSpan(
+  spanName: string,
+  handleResponseErrors: (rootSpan: Span) => Promise<Response>,
 ): 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,
-          },
-        });
-      }
-    },
-  );
+  const activeSpan = getActiveSpan();
+  const rootSpan = activeSpan && getRootSpan(activeSpan);
 
-  try {
-    if (rootSpan && response.status) {
-      setHttpStatus(rootSpan, response.status);
-    }
-  } catch {
-    // best effort - response may be undefined?
-  }
+  if (rootSpan) {
+    rootSpan.updateName(spanName);
+    rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'route');
+    rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'http.server');
+    rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.function.nextjs');
 
-  return response;
+    return handleResponseErrors(rootSpan);
+  } else {
+    return startSpan(
+      {
+        op: 'http.server',
+        name: spanName,
+        forceTransaction: true,
+        attributes: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
+        },
+      },
+      (span: Span) => {
+        return handleResponseErrors(span);
+      },
+    );
+  }
 }
 
 /**
@@ -78,27 +75,35 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
         });
 
         try {
-          const activeSpan = getActiveSpan();
-          const rootSpan = activeSpan && getRootSpan(activeSpan);
-
-          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',
-                },
+          return await startOrUpdateSpan(`${method} ${parameterizedRoute}`, async (rootSpan: Span) => {
+            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,
+                    },
+                  });
+                }
               },
-              async span => addSpanAttributes(originalFunction, thisArg, args, span),
             );
-          }
+
+            try {
+              if (rootSpan && response.status) {
+                setHttpStatus(rootSpan, response.status);
+              }
+            } catch {
+              // best effort - response may be undefined?
+            }
+
+            return response;
+          });
         } finally {
           if (!platformSupportsStreaming() || process.env.NEXT_RUNTIME === 'edge') {
             // 1. Edge transport requires manual flushing

packages/nextjs/src/server/index.ts

@@ -12,6 +12,7 @@ import { onUncaughtExceptionIntegration } from './onUncaughtExceptionIntegration
 
 export * from '@sentry/node';
 import type { EventProcessor } from '@sentry/types';
+import { requestIsolationScopeIntegration } from './requestIsolationScopeIntegration';
 
 export { captureUnderscoreErrorException } from '../common/_error';
 export { onUncaughtExceptionIntegration } from './onUncaughtExceptionIntegration';
@@ -81,6 +82,7 @@ export function init(options: NodeOptions): void {
         integration.name !== 'Http',
     ),
     onUncaughtExceptionIntegration(),
+    requestIsolationScopeIntegration(),
   ];
 
   // This value is injected at build time, based on the output directory specified in the build config. Though a default

packages/opentelemetry/src/sampler.ts

@@ -75,6 +75,7 @@ export class SentrySampler implements Sampler {
 
     const method = `${spanAttributes[SemanticAttributes.HTTP_METHOD]}`.toUpperCase();
     if (method === 'OPTIONS' || method === 'HEAD') {
+      DEBUG_BUILD && logger.log(`[Tracing] Not sampling span because HTTP method is '${method}' for ${spanName}`);
       return {
         decision: SamplingDecision.NOT_RECORD,
         attributes,

packages/opentelemetry/src/utils/mapStatus.ts

@@ -26,6 +26,10 @@ const canonicalGrpcErrorCodesMap: Record<string, SpanStatus['message']> = {
   '16': 'unauthenticated',
 } as const;
 
+const isStatusErrorMessageValid = (message: string): boolean => {
+  return Object.values(canonicalGrpcErrorCodesMap).includes(message as SpanStatus['message']);
+};
+
 /**
  * Get a Sentry span status from an otel span.
  */
@@ -39,7 +43,11 @@ export function mapStatus(span: AbstractSpan): SpanStatus {
       return { code: SPAN_STATUS_OK };
       // If the span is already marked as erroneous we return that exact status
     } else if (status.code === SpanStatusCode.ERROR) {
-      return { code: SPAN_STATUS_ERROR, message: status.message };
+      if (typeof status.message === 'undefined' || isStatusErrorMessageValid(status.message)) {
+        return { code: SPAN_STATUS_ERROR, message: status.message };
+      } else {
+        return { code: SPAN_STATUS_ERROR, message: 'unknown_error' };
+      }
     }
   }