test: update e2e tests with middleware hook instrumentation

Author: logaretm

dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/04.hooks.ts

@@ -0,0 +1,36 @@
+import { defineEventHandler, setHeader, getQuery } from '#imports';
+
+export default defineEventHandler({
+  onRequest: async event => {
+    // Set a header to indicate the onRequest hook ran
+    setHeader(event, 'x-hooks-onrequest', 'executed');
+
+    // Check if we should throw an error in onRequest
+    const query = getQuery(event);
+    if (query.throwOnRequestError === 'true') {
+      throw new Error('OnRequest hook error');
+    }
+  },
+
+  handler: async event => {
+    // Set a header to indicate the main handler ran
+    setHeader(event, 'x-hooks-handler', 'executed');
+
+    // Check if we should throw an error in handler
+    const query = getQuery(event);
+    if (query.throwHandlerError === 'true') {
+      throw new Error('Handler error');
+    }
+  },
+
+  onBeforeResponse: async (event, response) => {
+    // Set a header to indicate the onBeforeResponse hook ran
+    setHeader(event, 'x-hooks-onbeforeresponse', 'executed');
+
+    // Check if we should throw an error in onBeforeResponse
+    const query = getQuery(event);
+    if (query.throwOnBeforeResponseError === 'true') {
+      throw new Error('OnBeforeResponse hook error');
+    }
+  },
+});

dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/05.array-hooks.ts

@@ -0,0 +1,47 @@
+import { defineEventHandler, setHeader, getQuery } from '#imports';
+
+export default defineEventHandler({
+  // Array of onRequest handlers
+  onRequest: [
+    async event => {
+      setHeader(event, 'x-array-onrequest-0', 'executed');
+
+      const query = getQuery(event);
+      if (query.throwOnRequest0Error === 'true') {
+        throw new Error('OnRequest[0] hook error');
+      }
+    },
+    async event => {
+      setHeader(event, 'x-array-onrequest-1', 'executed');
+
+      const query = getQuery(event);
+      if (query.throwOnRequest1Error === 'true') {
+        throw new Error('OnRequest[1] hook error');
+      }
+    },
+  ],
+
+  handler: async event => {
+    setHeader(event, 'x-array-handler', 'executed');
+  },
+
+  // Array of onBeforeResponse handlers
+  onBeforeResponse: [
+    async (event, response) => {
+      setHeader(event, 'x-array-onbeforeresponse-0', 'executed');
+
+      const query = getQuery(event);
+      if (query.throwOnBeforeResponse0Error === 'true') {
+        throw new Error('OnBeforeResponse[0] hook error');
+      }
+    },
+    async (event, response) => {
+      setHeader(event, 'x-array-onbeforeresponse-1', 'executed');
+
+      const query = getQuery(event);
+      if (query.throwOnBeforeResponse1Error === 'true') {
+        throw new Error('OnBeforeResponse[1] hook error');
+      }
+    },
+  ],
+});

dev-packages/e2e-tests/test-applications/nuxt-3/tests/middleware.test.ts

@@ -19,16 +19,23 @@ test.describe('Server Middleware Instrumentation', () => {
     // Verify that we have spans for each middleware
     const middlewareSpans = serverTxnEvent.spans?.filter(span => span.op === 'middleware.nuxt') || [];
 
-    expect(middlewareSpans).toHaveLength(3);
+    // 3 simple + 3 hooks (onRequest+handler+onBeforeResponse) + 5 array hooks (2 onRequest + 1 handler + 2 onBeforeResponse)
+    expect(middlewareSpans).toHaveLength(11);
 
     // Check for specific middleware spans
-    const firstMiddlewareSpan = middlewareSpans.find(span => span.data?.['nuxt.middleware.name'] === '01.first.ts');
-    const secondMiddlewareSpan = middlewareSpans.find(span => span.data?.['nuxt.middleware.name'] === '02.second.ts');
-    const authMiddlewareSpan = middlewareSpans.find(span => span.data?.['nuxt.middleware.name'] === '03.auth.ts');
+    const firstMiddlewareSpan = middlewareSpans.find(span => span.data?.['nuxt.middleware.name'] === '01.first');
+    const secondMiddlewareSpan = middlewareSpans.find(span => span.data?.['nuxt.middleware.name'] === '02.second');
+    const authMiddlewareSpan = middlewareSpans.find(span => span.data?.['nuxt.middleware.name'] === '03.auth');
+    const hooksOnRequestSpan = middlewareSpans.find(span => span.data?.['nuxt.middleware.name'] === '04.hooks');
+    const arrayHooksHandlerSpan = middlewareSpans.find(
+      span => span.data?.['nuxt.middleware.name'] === '05.array-hooks',
+    );
 
     expect(firstMiddlewareSpan).toBeDefined();
     expect(secondMiddlewareSpan).toBeDefined();
     expect(authMiddlewareSpan).toBeDefined();
+    expect(hooksOnRequestSpan).toBeDefined();
+    expect(arrayHooksHandlerSpan).toBeDefined();
 
     // Verify each span has the correct attributes
     [firstMiddlewareSpan, secondMiddlewareSpan, authMiddlewareSpan].forEach(span => {
@@ -37,7 +44,7 @@ test.describe('Server Middleware Instrumentation', () => {
           op: 'middleware.nuxt',
           data: expect.objectContaining({
             'sentry.op': 'middleware.nuxt',
-            'sentry.origin': 'auto.http.nuxt',
+            'sentry.origin': 'auto.middleware.nuxt',
             'sentry.source': 'custom',
             'http.request.method': 'GET',
             'http.route': '/api/middleware-test',
@@ -52,7 +59,8 @@ test.describe('Server Middleware Instrumentation', () => {
     // Verify spans have different span IDs (each middleware gets its own span)
     const spanIds = middlewareSpans.map(span => span.span_id);
     const uniqueSpanIds = new Set(spanIds);
-    expect(uniqueSpanIds.size).toBe(3);
+    // 3 simple + 3 hooks (onRequest+handler+onBeforeResponse) + 5 array hooks (2 onRequest + 1 handler + 2 onBeforeResponse)
+    expect(uniqueSpanIds.size).toBe(11);
 
     // Verify spans share the same trace ID
     const traceIds = middlewareSpans.map(span => span.trace_id);
@@ -95,7 +103,7 @@ test.describe('Server Middleware Instrumentation', () => {
 
     // Find the auth middleware span
     const authMiddlewareSpan = serverTxnEvent.spans?.find(
-      span => span.op === 'middleware.nuxt' && span.data?.['nuxt.middleware.name'] === '03.auth.ts',
+      span => span.op === 'middleware.nuxt' && span.data?.['nuxt.middleware.name'] === '03.auth',
     );
 
     expect(authMiddlewareSpan).toBeDefined();
@@ -113,9 +121,212 @@ test.describe('Server Middleware Instrumentation', () => {
         type: 'Error',
         mechanism: expect.objectContaining({
           handled: false,
-          type: 'auto.http.nuxt',
+          type: 'auto.middleware.nuxt',
         }),
       }),
     );
   });
+
+  test('should create spans for onRequest and onBeforeResponse hooks', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-3', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    // Make request to trigger middleware with hooks
+    const response = await request.get('/api/middleware-test');
+    expect(response.status()).toBe(200);
+
+    const serverTxnEvent = await serverTxnEventPromise;
+    const middlewareSpans = serverTxnEvent.spans?.filter(span => span.op === 'middleware.nuxt') || [];
+
+    // Find spans for the hooks middleware
+    const hooksSpans = middlewareSpans.filter(span => span.data?.['nuxt.middleware.name'] === '04.hooks');
+
+    // Should have spans for onRequest, handler, and onBeforeResponse
+    expect(hooksSpans).toHaveLength(3);
+
+    // Find specific hook spans
+    const onRequestSpan = hooksSpans.find(span => span.data?.['nuxt.middleware.hook.name'] === 'onRequest');
+    const handlerSpan = hooksSpans.find(span => span.data?.['nuxt.middleware.hook.name'] === 'handler');
+    const onBeforeResponseSpan = hooksSpans.find(
+      span => span.data?.['nuxt.middleware.hook.name'] === 'onBeforeResponse',
+    );
+
+    expect(onRequestSpan).toBeDefined();
+    expect(handlerSpan).toBeDefined();
+    expect(onBeforeResponseSpan).toBeDefined();
+
+    // Verify span names include hook types
+    expect(onRequestSpan?.description).toBe('04.hooks.onRequest');
+    expect(handlerSpan?.description).toBe('04.hooks');
+    expect(onBeforeResponseSpan?.description).toBe('04.hooks.onBeforeResponse');
+
+    // Verify all spans have correct middleware name (without hook suffix)
+    [onRequestSpan, handlerSpan, onBeforeResponseSpan].forEach(span => {
+      expect(span?.data?.['nuxt.middleware.name']).toBe('04.hooks');
+    });
+
+    // Verify hook-specific attributes
+    expect(onRequestSpan?.data?.['nuxt.middleware.hook.name']).toBe('onRequest');
+    expect(handlerSpan?.data?.['nuxt.middleware.hook.name']).toBe('handler');
+    expect(onBeforeResponseSpan?.data?.['nuxt.middleware.hook.name']).toBe('onBeforeResponse');
+
+    // Verify no index attributes for single hooks
+    expect(onRequestSpan?.data).not.toHaveProperty('nuxt.middleware.hook.index');
+    expect(handlerSpan?.data).not.toHaveProperty('nuxt.middleware.hook.index');
+    expect(onBeforeResponseSpan?.data).not.toHaveProperty('nuxt.middleware.hook.index');
+  });
+
+  test('should create spans with index attributes for array hooks', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-3', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    // Make request to trigger middleware with array hooks
+    const response = await request.get('/api/middleware-test');
+    expect(response.status()).toBe(200);
+
+    const serverTxnEvent = await serverTxnEventPromise;
+    const middlewareSpans = serverTxnEvent.spans?.filter(span => span.op === 'middleware.nuxt') || [];
+
+    // Find spans for the array hooks middleware
+    const arrayHooksSpans = middlewareSpans.filter(span => span.data?.['nuxt.middleware.name'] === '05.array-hooks');
+
+    // Should have spans for 2 onRequest + 1 handler + 2 onBeforeResponse = 5 spans
+    expect(arrayHooksSpans).toHaveLength(5);
+
+    // Find onRequest array spans
+    const onRequestSpans = arrayHooksSpans.filter(span => span.data?.['nuxt.middleware.hook.name'] === 'onRequest');
+    expect(onRequestSpans).toHaveLength(2);
+
+    // Find onBeforeResponse array spans
+    const onBeforeResponseSpans = arrayHooksSpans.filter(
+      span => span.data?.['nuxt.middleware.hook.name'] === 'onBeforeResponse',
+    );
+    expect(onBeforeResponseSpans).toHaveLength(2);
+
+    // Find handler span
+    const handlerSpan = arrayHooksSpans.find(span => span.data?.['nuxt.middleware.hook.name'] === 'handler');
+    expect(handlerSpan).toBeDefined();
+
+    // Verify index attributes for onRequest array
+    const onRequest0Span = onRequestSpans.find(span => span.data?.['nuxt.middleware.hook.index'] === 0);
+    const onRequest1Span = onRequestSpans.find(span => span.data?.['nuxt.middleware.hook.index'] === 1);
+
+    expect(onRequest0Span).toBeDefined();
+    expect(onRequest1Span).toBeDefined();
+
+    // Verify index attributes for onBeforeResponse array
+    const onBeforeResponse0Span = onBeforeResponseSpans.find(span => span.data?.['nuxt.middleware.hook.index'] === 0);
+    const onBeforeResponse1Span = onBeforeResponseSpans.find(span => span.data?.['nuxt.middleware.hook.index'] === 1);
+
+    expect(onBeforeResponse0Span).toBeDefined();
+    expect(onBeforeResponse1Span).toBeDefined();
+
+    // Verify span names for array handlers
+    expect(onRequest0Span?.description).toBe('05.array-hooks.onRequest');
+    expect(onRequest1Span?.description).toBe('05.array-hooks.onRequest');
+    expect(onBeforeResponse0Span?.description).toBe('05.array-hooks.onBeforeResponse');
+    expect(onBeforeResponse1Span?.description).toBe('05.array-hooks.onBeforeResponse');
+
+    // Verify handler has no index
+    expect(handlerSpan?.data).not.toHaveProperty('nuxt.middleware.hook.index');
+  });
+
+  test('should handle errors in onRequest hooks', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-3', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    const errorEventPromise = waitForError('nuxt-3', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'OnRequest hook error';
+    });
+
+    // Make request with query param to trigger error in onRequest
+    const response = await request.get('/api/middleware-test?throwOnRequestError=true');
+    expect(response.status()).toBe(500);
+
+    const [serverTxnEvent, errorEvent] = await Promise.all([serverTxnEventPromise, errorEventPromise]);
+
+    // Find the onRequest span that should have error status
+    const onRequestSpan = serverTxnEvent.spans?.find(
+      span =>
+        span.op === 'middleware.nuxt' &&
+        span.data?.['nuxt.middleware.name'] === '04.hooks' &&
+        span.data?.['nuxt.middleware.hook.name'] === 'onRequest',
+    );
+
+    expect(onRequestSpan).toBeDefined();
+    expect(onRequestSpan?.status).toBe('internal_error');
+    expect(errorEvent.exception?.values?.[0]?.value).toBe('OnRequest hook error');
+  });
+
+  test('should handle errors in onBeforeResponse hooks', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-3', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    const errorEventPromise = waitForError('nuxt-3', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'OnBeforeResponse hook error';
+    });
+
+    // Make request with query param to trigger error in onBeforeResponse
+    const response = await request.get('/api/middleware-test?throwOnBeforeResponseError=true');
+    expect(response.status()).toBe(500);
+
+    const [serverTxnEvent, errorEvent] = await Promise.all([serverTxnEventPromise, errorEventPromise]);
+
+    // Find the onBeforeResponse span that should have error status
+    const onBeforeResponseSpan = serverTxnEvent.spans?.find(
+      span =>
+        span.op === 'middleware.nuxt' &&
+        span.data?.['nuxt.middleware.name'] === '04.hooks' &&
+        span.data?.['nuxt.middleware.hook.name'] === 'onBeforeResponse',
+    );
+
+    expect(onBeforeResponseSpan).toBeDefined();
+    expect(onBeforeResponseSpan?.status).toBe('internal_error');
+    expect(errorEvent.exception?.values?.[0]?.value).toBe('OnBeforeResponse hook error');
+  });
+
+  test('should handle errors in array hooks with proper index attribution', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-3', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    const errorEventPromise = waitForError('nuxt-3', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'OnRequest[1] hook error';
+    });
+
+    // Make request with query param to trigger error in second onRequest handler
+    const response = await request.get('/api/middleware-test?throwOnRequest1Error=true');
+    expect(response.status()).toBe(500);
+
+    const [serverTxnEvent, errorEvent] = await Promise.all([serverTxnEventPromise, errorEventPromise]);
+
+    // Find the second onRequest span that should have error status
+    const onRequest1Span = serverTxnEvent.spans?.find(
+      span =>
+        span.op === 'middleware.nuxt' &&
+        span.data?.['nuxt.middleware.name'] === '05.array-hooks' &&
+        span.data?.['nuxt.middleware.hook.name'] === 'onRequest' &&
+        span.data?.['nuxt.middleware.hook.index'] === 1,
+    );
+
+    expect(onRequest1Span).toBeDefined();
+    expect(onRequest1Span?.status).toBe('internal_error');
+    expect(errorEvent.exception?.values?.[0]?.value).toBe('OnRequest[1] hook error');
+
+    // Verify the first onRequest handler still executed successfully
+    const onRequest0Span = serverTxnEvent.spans?.find(
+      span =>
+        span.op === 'middleware.nuxt' &&
+        span.data?.['nuxt.middleware.name'] === '05.array-hooks' &&
+        span.data?.['nuxt.middleware.hook.name'] === 'onRequest' &&
+        span.data?.['nuxt.middleware.hook.index'] === 0,
+    );
+
+    expect(onRequest0Span).toBeDefined();
+    expect(onRequest0Span?.status).not.toBe('internal_error');
+  });
 });

dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/04.hooks.ts

@@ -0,0 +1,36 @@
+import { defineEventHandler, setHeader, getQuery } from '#imports';
+
+export default defineEventHandler({
+  onRequest: async event => {
+    // Set a header to indicate the onRequest hook ran
+    setHeader(event, 'x-hooks-onrequest', 'executed');
+
+    // Check if we should throw an error in onRequest
+    const query = getQuery(event);
+    if (query.throwOnRequestError === 'true') {
+      throw new Error('OnRequest hook error');
+    }
+  },
+
+  handler: async event => {
+    // Set a header to indicate the main handler ran
+    setHeader(event, 'x-hooks-handler', 'executed');
+
+    // Check if we should throw an error in handler
+    const query = getQuery(event);
+    if (query.throwHandlerError === 'true') {
+      throw new Error('Handler error');
+    }
+  },
+
+  onBeforeResponse: async (event, response) => {
+    // Set a header to indicate the onBeforeResponse hook ran
+    setHeader(event, 'x-hooks-onbeforeresponse', 'executed');
+
+    // Check if we should throw an error in onBeforeResponse
+    const query = getQuery(event);
+    if (query.throwOnBeforeResponseError === 'true') {
+      throw new Error('OnBeforeResponse hook error');
+    }
+  },
+});