Remove Http integration from Next.js

Author: s1gr1d

packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts

@@ -1,16 +1,14 @@
 import {
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   SPAN_STATUS_ERROR,
   addTracingExtensions,
   captureException,
-  continueTrace,
+  getActiveSpan,
+  getIsolationScope,
+  getRootSpan,
   handleCallbackErrors,
   setHttpStatus,
-  startSpan,
 } from '@sentry/core';
 import { winterCGHeadersToDict } from '@sentry/utils';
-
 import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavigationErrorUtils';
 import type { RouteHandlerContext } from './types';
 import { platformSupportsStreaming } from './utils/platformSupportsStreaming';
@@ -26,73 +24,55 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
   context: RouteHandlerContext,
 ): (...args: Parameters<F>) => ReturnType<F> extends Promise<unknown> ? ReturnType<F> : Promise<ReturnType<F>> {
   addTracingExtensions();
-  const { method, parameterizedRoute, headers } = context;
+
+  const { headers } = context;
+
   return new Proxy(routeHandler, {
-    apply: (originalFunction, thisArg, args) => {
-      return withIsolationScopeOrReuseFromRootSpan(async isolationScope => {
-        isolationScope.setSDKProcessingMetadata({
-          request: {
-            headers: headers ? winterCGHeadersToDict(headers) : undefined,
-          },
-        });
-        return continueTrace(
-          {
-            // TODO(v8): Make it so that continue trace will allow null as sentryTrace value and remove this fallback here
-            sentryTrace: headers?.get('sentry-trace') ?? undefined,
-            baggage: headers?.get('baggage'),
-          },
-          async () => {
-            try {
-              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 => {
-                  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)) {
-                        span.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
-                      } else {
-                        captureException(error, {
-                          mechanism: {
-                            handled: false,
-                          },
-                        });
-                      }
-                    },
-                  );
+    apply: async (originalFunction, thisArg, args) => {
+      getIsolationScope().setSDKProcessingMetadata({
+        request: {
+          headers: headers ? winterCGHeadersToDict(headers) : undefined,
+        },
+      });
 
-                  try {
-                    if (span && response.status) {
-                      setHttpStatus(span, response.status);
-                    }
-                  } catch {
-                    // best effort - response may be undefined?
-                  }
+      try {
+        const activeSpan = getActiveSpan();
+        const rootSpan = activeSpan && getRootSpan(activeSpan);
 
-                  return 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,
                 },
-              );
-            } finally {
-              if (!platformSupportsStreaming() || process.env.NEXT_RUNTIME === 'edge') {
-                // 1. Edge transport requires manual flushing
-                // 2. Lambdas require manual flushing to prevent execution freeze before the event is sent
-                await flushQueue();
-              }
+              });
             }
           },
         );
-      });
+
+        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
+          // 2. Lambdas require manual flushing to prevent execution freeze before the event is sent
+          await flushQueue();
+        }
+      }
     },
   });
 }

packages/nextjs/src/server/index.ts

@@ -75,8 +75,9 @@ export function init(options: NodeOptions): void {
     ...getDefaultIntegrations(options).filter(
       integration =>
         integration.name !== 'OnUncaughtException' &&
-        // Next.js comes with its own Node-Fetch instrumentation so we shouldn't add ours on-top
-        integration.name !== 'NodeFetch',
+        // Next.js comes with its own Node-Fetch and Http instrumentation, so we shouldn't add ours on-top
+        integration.name !== 'NodeFetch' &&
+        integration.name !== 'Http',
     ),
     onUncaughtExceptionIntegration(),
   ];