feat(nuxt): Implement server middleware instrumentation (getsentry#17796)

This pull request introduces instrumentation for Nuxt middleware,
ensuring that all middleware handlers are automatically wrapped with
tracing and error reporting functionality. The integration is achieved
through build-time transformation.

recap:

* Adds a new build-time Rollup plugin
(`middlewareInstrumentationPlugin`) that automatically wraps all
detected middleware handlers with Sentry instrumentation during the
Nitro build process.
* Implements the `wrapMiddlewareHandler` utility, which wraps middleware
handlers to start a Sentry span, capture request data, record
exceptions, and flush events in serverless environments.
* Updates the Nuxt module setup to inject Sentry middleware imports and
instrumentation hooks during initialization, ensuring the new tracing
logic is included in server builds.


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Adds build-time wrapping of Nuxt server middleware with Sentry spans
and error capture, plus Nuxt 3/4 e2e and unit tests.
> 
> - **SDK/Runtime**:
> - Implement `wrapMiddlewareHandlerWithSentry` in
`packages/nuxt/src/runtime/hooks/wrapMiddlewareHandler.ts` to start
spans, set attributes (op, origin, route, method, headers), handle hook
arrays (`onRequest`, `onBeforeResponse`), and capture errors.
> - Add middleware build-time transformation via
`packages/nuxt/src/vite/middlewareConfig.ts` (server import + Rollup
plugin to wrap `defineEventHandler`/`eventHandler`).
> - Integrate instrumentation in `packages/nuxt/src/module.ts` by
calling `addMiddlewareImports` and `addMiddlewareInstrumentation` during
Nitro init when server config is present.
> - **Tests**:
> - Add e2e apps and Playwright tests for Nuxt 3 and Nuxt 4
(`dev-packages/e2e-tests/test-applications/nuxt-{3,4}`) covering span
creation, attributes, parent-child relationships, and error propagation
across hooks and arrays.
> - Add unit tests for wrapper behavior in
`packages/nuxt/test/runtime/hooks/wrapMiddlewareHandler.test.ts`.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
9a4a1f3. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: logaretm

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

@@ -0,0 +1,15 @@
+import { defineEventHandler, getHeader } from '#imports';
+
+export default defineEventHandler(async event => {
+  // Simple API endpoint that will trigger all server middleware
+  return {
+    message: 'Server middleware test endpoint',
+    path: event.path,
+    method: event.method,
+    headers: {
+      'x-first-middleware': getHeader(event, 'x-first-middleware'),
+      'x-second-middleware': getHeader(event, 'x-second-middleware'),
+      'x-auth-middleware': getHeader(event, 'x-auth-middleware'),
+    },
+  };
+});

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

@@ -0,0 +1,6 @@
+import { defineEventHandler, setHeader } from '#imports';
+
+export default defineEventHandler(async event => {
+  // Set a header to indicate this middleware ran
+  setHeader(event, 'x-first-middleware', 'executed');
+});

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

@@ -0,0 +1,7 @@
+import { eventHandler, setHeader } from '#imports';
+
+// tests out the eventHandler alias
+export default eventHandler(async event => {
+  // Set a header to indicate this middleware ran
+  setHeader(event, 'x-second-middleware', 'executed');
+});

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

@@ -0,0 +1,12 @@
+import { defineEventHandler, setHeader, getQuery } from '#imports';
+
+export default defineEventHandler(async event => {
+  // Check if we should throw an error
+  const query = getQuery(event);
+  if (query.throwError === 'true') {
+    throw new Error('Auth middleware error');
+  }
+
+  // Set a header to indicate this middleware ran
+  setHeader(event, 'x-auth-middleware', 'executed');
+});

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');
+      }
+    },
+  ],
+});