fix: remove uneeded isolation scope calls

Author: logaretm

packages/nuxt/src/runtime/hooks/wrapMiddlewareHandler.ts

@@ -1,21 +1,15 @@
 import {
-  type RequestEventData,
   type SpanAttributes,
   captureException,
   debug,
   flushIfServerless,
   getClient,
-  getDefaultIsolationScope,
-  getIsolationScope,
   httpHeadersToSpanAttributes,
-  httpRequestToRequestData,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
-  SPAN_STATUS_ERROR,
   SPAN_STATUS_OK,
   startSpan,
-  withIsolationScope,
 } from '@sentry/core';
 import type { EventHandler, EventHandlerRequest, H3Event } from 'h3';
 
@@ -29,63 +23,37 @@ export function wrapMiddlewareHandler(handler: EventHandler, fileName: string) {
   return async (event: H3Event<EventHandlerRequest>) => {
     debug.log(`Sentry middleware: ${fileName} handling ${event.path}`);
 
-    const isolationScope = getIsolationScope();
-    const newIsolationScope = isolationScope === getDefaultIsolationScope() ? isolationScope.clone() : isolationScope;
-    const normalizedRequest = createNormalizedRequestData(event);
-    newIsolationScope.setSDKProcessingMetadata({
-      normalizedRequest,
-    });
-
     const attributes = getSpanAttributes(event, fileName);
 
-    return withIsolationScope(newIsolationScope, async () => {
-      return startSpan(
-        {
-          name: fileName,
-          attributes,
-        },
-        async span => {
-          try {
-            const result = await handler(event);
-            span.setStatus({ code: SPAN_STATUS_OK });
+    return startSpan(
+      {
+        name: fileName,
+        attributes,
+      },
+      async span => {
+        try {
+          const result = await handler(event);
+          span.setStatus({ code: SPAN_STATUS_OK });
 
-            return result;
-          } catch (error) {
-            span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });
-            span.recordException(error);
-            captureException(error, {
-              mechanism: {
-                handled: false,
-                type: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN],
-              },
-            });
-            span.end();
+          return result;
+        } catch (error) {
+          captureException(error, {
+            mechanism: {
+              handled: false,
+              type: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN],
+            },
+          });
 
-            // Re-throw the error to be handled by the caller
-            throw error;
-          } finally {
-            await flushIfServerless();
-          }
-        },
-      );
-    });
+          // Re-throw the error to be handled by the caller
+          throw error;
+        } finally {
+          await flushIfServerless();
+        }
+      },
+    );
   };
 }
 
-/**
- * Creates the normalized request data for the middleware handler based on the event.
- */
-function createNormalizedRequestData(event: H3Event<EventHandlerRequest>): RequestEventData {
-  // Extract headers from the Node.js request object
-  const headers = event.node?.req?.headers || {};
-
-  return httpRequestToRequestData({
-    method: event.method,
-    url: event.path || event.node?.req?.url,
-    headers,
-  });
-}
-
 /**
  * Gets the span attributes for the middleware handler based on the event.
  */

packages/nuxt/test/runtime/hooks/wrapMiddlewareHandler.test.ts

@@ -10,12 +10,8 @@ vi.mock('@sentry/core', async importOriginal => {
     ...(mod as any),
     debug: { log: vi.fn() },
     startSpan: vi.fn(),
-    withIsolationScope: vi.fn(),
-    getIsolationScope: vi.fn(),
-    getDefaultIsolationScope: vi.fn(),
     getClient: vi.fn(),
     httpHeadersToSpanAttributes: vi.fn(),
-    httpRequestToRequestData: vi.fn(),
     captureException: vi.fn(),
     flushIfServerless: vi.fn(),
   };
@@ -39,22 +35,13 @@ describe('wrapMiddlewareHandler', () => {
     end: vi.fn(),
   };
 
-  const mockIsolationScope = {
-    clone: vi.fn().mockReturnValue('cloned-scope'),
-    setSDKProcessingMetadata: vi.fn(),
-  };
-
   beforeEach(() => {
     vi.clearAllMocks();
 
     // Setup minimal required mocks
-    (SentryCore.getIsolationScope as any).mockReturnValue(mockIsolationScope);
-    (SentryCore.getDefaultIsolationScope as any).mockReturnValue('default-scope');
-    (SentryCore.withIsolationScope as any).mockImplementation((_scope: any, callback: any) => callback());
     (SentryCore.startSpan as any).mockImplementation((_config: any, callback: any) => callback(mockSpan));
     (SentryCore.getClient as any).mockReturnValue({ getOptions: () => ({ sendDefaultPii: false }) });
     (SentryCore.httpHeadersToSpanAttributes as any).mockReturnValue({ 'http.request.header.user_agent': 'test-agent' });
-    (SentryCore.httpRequestToRequestData as any).mockReturnValue({ url: '/test-path', method: 'GET' });
     (SentryCore.flushIfServerless as any).mockResolvedValue(undefined);
   });
 
@@ -109,7 +96,6 @@ describe('wrapMiddlewareHandler', () => {
 
       // Verify Sentry APIs were called but error was not masked
       expect(SentryCore.captureException).toHaveBeenCalledWith(originalError, expect.any(Object));
-      expect(mockSpan.recordException).toHaveBeenCalledWith(originalError);
     });
 
     it('should propagate sync errors without modification', async () => {
@@ -151,9 +137,6 @@ describe('wrapMiddlewareHandler', () => {
 
       // This should handle the Sentry error gracefully and still call user code
       await expect(wrapped(mockEvent)).rejects.toThrow('Sentry API failure');
-
-      // But user handler should still have been attempted to be called
-      // (this tests that we don't fail before reaching user code)
     });
   });
 
@@ -169,20 +152,14 @@ describe('wrapMiddlewareHandler', () => {
         expect.objectContaining({
           name: 'api-middleware',
           attributes: expect.objectContaining({
-            [SentryCore.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server.middleware',
+            [SentryCore.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'middleware.nuxt',
             'nuxt.middleware.name': 'api-middleware',
             'http.request.method': 'GET',
             'http.route': '/test-path',
           }),
         }),
         expect.any(Function),
       );
-
-      expect(SentryCore.httpRequestToRequestData).toHaveBeenCalledWith({
-        method: 'GET',
-        url: '/test-path',
-        headers: { 'user-agent': 'test-agent' },
-      });
     });
 
     it('should handle missing optional data gracefully', async () => {