diff --git a/dev-packages/e2e-tests/test-applications/nuxt-3/server/api/middleware-test.ts b/dev-packages/e2e-tests/test-applications/nuxt-3/server/api/middleware-test.ts
new file mode 100644
index 000000000000..8973690e6adb
--- /dev/null
+++ b/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'),
+    },
+  };
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/01.first.ts b/dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/01.first.ts
new file mode 100644
index 000000000000..b146c42e3483
--- /dev/null
+++ b/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');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/02.second.ts b/dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/02.second.ts
new file mode 100644
index 000000000000..3b665d48fc5a
--- /dev/null
+++ b/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');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/03.auth.ts b/dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/03.auth.ts
new file mode 100644
index 000000000000..6dcd9a075589
--- /dev/null
+++ b/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');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/04.hooks.ts b/dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/04.hooks.ts
new file mode 100644
index 000000000000..1f9cf40a1c02
--- /dev/null
+++ b/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');
+    }
+  },
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/05.array-hooks.ts b/dev-packages/e2e-tests/test-applications/nuxt-3/server/middleware/05.array-hooks.ts
new file mode 100644
index 000000000000..cc815bfb2fbf
--- /dev/null
+++ b/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');
+      }
+    },
+  ],
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-3/tests/middleware.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-3/tests/middleware.test.ts
new file mode 100644
index 000000000000..e9debf8496c2
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-3/tests/middleware.test.ts
@@ -0,0 +1,332 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction, waitForError } from '@sentry-internal/test-utils';
+
+test.describe('Server Middleware Instrumentation', () => {
+  test('should create separate spans for each server middleware', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-3', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    // Make request to the API endpoint that will trigger all server middleware
+    const response = await request.get('/api/middleware-test');
+    expect(response.status()).toBe(200);
+
+    const responseData = await response.json();
+    expect(responseData.message).toBe('Server middleware test endpoint');
+
+    const serverTxnEvent = await serverTxnEventPromise;
+
+    // Verify that we have spans for each middleware
+    const middlewareSpans = serverTxnEvent.spans?.filter(span => span.op === 'middleware.nuxt') || [];
+
+    // 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');
+    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 => {
+      expect(span).toEqual(
+        expect.objectContaining({
+          op: 'middleware.nuxt',
+          data: expect.objectContaining({
+            'sentry.op': 'middleware.nuxt',
+            'sentry.origin': 'auto.middleware.nuxt',
+            'sentry.source': 'custom',
+            'http.request.method': 'GET',
+            'http.route': '/api/middleware-test',
+          }),
+          parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+          span_id: expect.stringMatching(/[a-f0-9]{16}/),
+          trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+        }),
+      );
+    });
+
+    // 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);
+    // 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);
+    const uniqueTraceIds = new Set(traceIds);
+    expect(uniqueTraceIds.size).toBe(1);
+  });
+
+  test('middleware spans should have proper parent-child relationship', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-3', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    await request.get('/api/middleware-test');
+    const serverTxnEvent = await serverTxnEventPromise;
+
+    const middlewareSpans = serverTxnEvent.spans?.filter(span => span.op === 'middleware.nuxt') || [];
+
+    // All middleware spans should be children of the main transaction
+    middlewareSpans.forEach(span => {
+      expect(span.parent_span_id).toBe(serverTxnEvent.contexts?.trace?.span_id);
+    });
+  });
+
+  test('should capture errors thrown in middleware and associate them with the span', 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 === 'Auth middleware error';
+    });
+
+    // Make request with query param to trigger error in auth middleware
+    const response = await request.get('/api/middleware-test?throwError=true');
+
+    // The request should fail due to the middleware error
+    expect(response.status()).toBe(500);
+
+    const [serverTxnEvent, errorEvent] = await Promise.all([serverTxnEventPromise, errorEventPromise]);
+
+    // Find the auth middleware span
+    const authMiddlewareSpan = serverTxnEvent.spans?.find(
+      span => span.op === 'middleware.nuxt' && span.data?.['nuxt.middleware.name'] === '03.auth',
+    );
+
+    expect(authMiddlewareSpan).toBeDefined();
+
+    // Verify the span has error status
+    expect(authMiddlewareSpan?.status).toBe('internal_error');
+
+    // Verify the error event is associated with the correct transaction
+    expect(errorEvent.transaction).toContain('GET /api/middleware-test');
+
+    // Verify the error has the correct mechanism
+    expect(errorEvent.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        value: 'Auth middleware error',
+        type: 'Error',
+        mechanism: expect.objectContaining({
+          handled: false,
+          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');
+  });
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/server/api/middleware-test.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/server/api/middleware-test.ts
new file mode 100644
index 000000000000..8973690e6adb
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/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'),
+    },
+  };
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/01.first.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/01.first.ts
new file mode 100644
index 000000000000..b146c42e3483
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/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');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/02.second.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/02.second.ts
new file mode 100644
index 000000000000..3b665d48fc5a
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/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');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/03.auth.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/03.auth.ts
new file mode 100644
index 000000000000..6dcd9a075589
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/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');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/04.hooks.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/04.hooks.ts
new file mode 100644
index 000000000000..1f9cf40a1c02
--- /dev/null
+++ b/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');
+    }
+  },
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/05.array-hooks.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/server/middleware/05.array-hooks.ts
new file mode 100644
index 000000000000..cc815bfb2fbf
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/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');
+      }
+    },
+  ],
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4/tests/middleware.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-4/tests/middleware.test.ts
new file mode 100644
index 000000000000..005330c01fee
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4/tests/middleware.test.ts
@@ -0,0 +1,332 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction, waitForError } from '@sentry-internal/test-utils';
+
+test.describe('Server Middleware Instrumentation', () => {
+  test('should create separate spans for each server middleware', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-4', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    // Make request to the API endpoint that will trigger all server middleware
+    const response = await request.get('/api/middleware-test');
+    expect(response.status()).toBe(200);
+
+    const responseData = await response.json();
+    expect(responseData.message).toBe('Server middleware test endpoint');
+
+    const serverTxnEvent = await serverTxnEventPromise;
+
+    // Verify that we have spans for each middleware
+    const middlewareSpans = serverTxnEvent.spans?.filter(span => span.op === 'middleware.nuxt') || [];
+
+    // 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');
+    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 => {
+      expect(span).toEqual(
+        expect.objectContaining({
+          op: 'middleware.nuxt',
+          data: expect.objectContaining({
+            'sentry.op': 'middleware.nuxt',
+            'sentry.origin': 'auto.middleware.nuxt',
+            'sentry.source': 'custom',
+            'http.request.method': 'GET',
+            'http.route': '/api/middleware-test',
+          }),
+          parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
+          span_id: expect.stringMatching(/[a-f0-9]{16}/),
+          trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+        }),
+      );
+    });
+
+    // 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);
+    // 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);
+    const uniqueTraceIds = new Set(traceIds);
+    expect(uniqueTraceIds.size).toBe(1);
+  });
+
+  test('middleware spans should have proper parent-child relationship', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-4', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    await request.get('/api/middleware-test');
+    const serverTxnEvent = await serverTxnEventPromise;
+
+    const middlewareSpans = serverTxnEvent.spans?.filter(span => span.op === 'middleware.nuxt') || [];
+
+    // All middleware spans should be children of the main transaction
+    middlewareSpans.forEach(span => {
+      expect(span.parent_span_id).toBe(serverTxnEvent.contexts?.trace?.span_id);
+    });
+  });
+
+  test('should capture errors thrown in middleware and associate them with the span', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-4', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    const errorEventPromise = waitForError('nuxt-4', errorEvent => {
+      return errorEvent?.exception?.values?.[0]?.value === 'Auth middleware error';
+    });
+
+    // Make request with query param to trigger error in auth middleware
+    const response = await request.get('/api/middleware-test?throwError=true');
+
+    // The request should fail due to the middleware error
+    expect(response.status()).toBe(500);
+
+    const [serverTxnEvent, errorEvent] = await Promise.all([serverTxnEventPromise, errorEventPromise]);
+
+    // Find the auth middleware span
+    const authMiddlewareSpan = serverTxnEvent.spans?.find(
+      span => span.op === 'middleware.nuxt' && span.data?.['nuxt.middleware.name'] === '03.auth',
+    );
+
+    expect(authMiddlewareSpan).toBeDefined();
+
+    // Verify the span has error status
+    expect(authMiddlewareSpan?.status).toBe('internal_error');
+
+    // Verify the error event is associated with the correct transaction
+    expect(errorEvent.transaction).toContain('GET /api/middleware-test');
+
+    // Verify the error has the correct mechanism
+    expect(errorEvent.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        value: 'Auth middleware error',
+        type: 'Error',
+        mechanism: expect.objectContaining({
+          handled: false,
+          type: 'auto.middleware.nuxt',
+        }),
+      }),
+    );
+  });
+
+  test('should create spans for onRequest and onBeforeResponse hooks', async ({ request }) => {
+    const serverTxnEventPromise = waitForTransaction('nuxt-4', 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-4', 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-4', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    const errorEventPromise = waitForError('nuxt-4', 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-4', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    const errorEventPromise = waitForError('nuxt-4', 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-4', txnEvent => {
+      return txnEvent.transaction?.includes('GET /api/middleware-test') ?? false;
+    });
+
+    const errorEventPromise = waitForError('nuxt-4', 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');
+  });
+});
diff --git a/packages/nuxt/src/module.ts b/packages/nuxt/src/module.ts
index 5e1343b1ebaa..7e9445a154a7 100644
--- a/packages/nuxt/src/module.ts
+++ b/packages/nuxt/src/module.ts
@@ -10,6 +10,7 @@ import { consoleSandbox } from '@sentry/core';
 import * as path from 'path';
 import type { SentryNuxtModuleOptions } from './common/types';
 import { addDynamicImportEntryFileWrapper, addSentryTopImport, addServerConfigToBuild } from './vite/addServerConfig';
+import { addMiddlewareImports, addMiddlewareInstrumentation } from './vite/middlewareConfig';
 import { setupSourceMaps } from './vite/sourceMaps';
 import { addOTelCommonJSImportAlias, findDefaultSdkInitFile } from './vite/utils';
 
@@ -110,7 +111,16 @@ export default defineNuxtModule<ModuleOptions>({
       };
     });
 
+    // Preps the the middleware instrumentation module.
+    if (serverConfigFile) {
+      addMiddlewareImports();
+    }
+
     nuxt.hooks.hook('nitro:init', nitro => {
+      if (serverConfigFile) {
+        addMiddlewareInstrumentation(nitro);
+      }
+
       if (serverConfigFile?.includes('.server.config')) {
         consoleSandbox(() => {
           const serverDir = nitro.options.output.serverDir;
diff --git a/packages/nuxt/src/runtime/hooks/wrapMiddlewareHandler.ts b/packages/nuxt/src/runtime/hooks/wrapMiddlewareHandler.ts
new file mode 100644
index 000000000000..a04b866cd774
--- /dev/null
+++ b/packages/nuxt/src/runtime/hooks/wrapMiddlewareHandler.ts
@@ -0,0 +1,193 @@
+import {
+  type SpanAttributes,
+  captureException,
+  debug,
+  flushIfServerless,
+  getClient,
+  httpHeadersToSpanAttributes,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
+  SPAN_STATUS_ERROR,
+  SPAN_STATUS_OK,
+  startSpan,
+} from '@sentry/core';
+import type {
+  _ResponseMiddleware as ResponseMiddleware,
+  EventHandler,
+  EventHandlerObject,
+  EventHandlerRequest,
+  EventHandlerResponse,
+  H3Event,
+} from 'h3';
+
+/**
+ * Wraps a middleware handler with Sentry instrumentation.
+ *
+ * @param handler The middleware handler.
+ * @param fileName The name of the middleware file.
+ */
+export function wrapMiddlewareHandlerWithSentry<THandler extends EventHandler | EventHandlerObject>(
+  handler: THandler,
+  fileName: string,
+): THandler {
+  if (!isEventHandlerObject(handler)) {
+    return wrapEventHandler(handler, fileName) as THandler;
+  }
+
+  const handlerObj = {
+    ...handler,
+    handler: wrapEventHandler(handler.handler, fileName),
+  };
+
+  if (handlerObj.onRequest) {
+    handlerObj.onRequest = normalizeHandlers(handlerObj.onRequest, (h, index) =>
+      wrapEventHandler(h, fileName, 'onRequest', index),
+    );
+  }
+
+  if (handlerObj.onBeforeResponse) {
+    handlerObj.onBeforeResponse = normalizeHandlers(handlerObj.onBeforeResponse, (h, index) =>
+      wrapResponseHandler(h, fileName, index),
+    );
+  }
+
+  return handlerObj;
+}
+
+/**
+ * Wraps a callable event handler with Sentry instrumentation.
+ *
+ * @param handler The event handler.
+ * @param handlerName The name of the event handler to be used for the span name and logging.
+ */
+function wrapEventHandler(
+  handler: EventHandler,
+  middlewareName: string,
+  hookName?: 'onRequest',
+  index?: number,
+): EventHandler {
+  return async (event: H3Event<EventHandlerRequest>) => {
+    debug.log(`Sentry middleware: ${middlewareName}${hookName ? `.${hookName}` : ''} handling ${event.path}`);
+
+    const attributes = getSpanAttributes(event, middlewareName, hookName, index);
+
+    return withSpan(() => handler(event), attributes, middlewareName, hookName);
+  };
+}
+
+/**
+ * Wraps a middleware response handler with Sentry instrumentation.
+ */
+function wrapResponseHandler(handler: ResponseMiddleware, middlewareName: string, index?: number): ResponseMiddleware {
+  return async (event: H3Event<EventHandlerRequest>, response: EventHandlerResponse) => {
+    debug.log(`Sentry middleware: ${middlewareName}.onBeforeResponse handling ${event.path}`);
+
+    const attributes = getSpanAttributes(event, middlewareName, 'onBeforeResponse', index);
+
+    return withSpan(() => handler(event, response), attributes, middlewareName, 'onBeforeResponse');
+  };
+}
+
+/**
+ * Wraps a middleware or event handler execution with a span.
+ */
+function withSpan<TResult>(
+  handler: () => TResult | Promise<TResult>,
+  attributes: SpanAttributes,
+  middlewareName: string,
+  hookName?: 'handler' | 'onRequest' | 'onBeforeResponse',
+): Promise<TResult> {
+  const spanName = hookName && hookName !== 'handler' ? `${middlewareName}.${hookName}` : middlewareName;
+
+  return startSpan(
+    {
+      name: spanName,
+      attributes,
+    },
+    async span => {
+      try {
+        const result = await handler();
+        span.setStatus({ code: SPAN_STATUS_OK });
+
+        return result;
+      } catch (error) {
+        span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_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();
+      }
+    },
+  );
+}
+
+/**
+ * Takes a list of handlers and wraps them with the normalizer function.
+ */
+function normalizeHandlers<T extends EventHandler | ResponseMiddleware>(
+  handlers: T | T[],
+  normalizer: (h: T, index?: number) => T,
+): T | T[] {
+  return Array.isArray(handlers) ? handlers.map((handler, index) => normalizer(handler, index)) : normalizer(handlers);
+}
+
+/**
+ * Gets the span attributes for the middleware handler based on the event.
+ */
+function getSpanAttributes(
+  event: H3Event<EventHandlerRequest>,
+  middlewareName: string,
+  hookName?: 'handler' | 'onRequest' | 'onBeforeResponse',
+  index?: number,
+): SpanAttributes {
+  const attributes: SpanAttributes = {
+    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'middleware.nuxt',
+    [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom',
+    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.middleware.nuxt',
+    'nuxt.middleware.name': middlewareName,
+    'nuxt.middleware.hook.name': hookName ?? 'handler',
+  };
+
+  // Add index for array handlers
+  if (typeof index === 'number') {
+    attributes['nuxt.middleware.hook.index'] = index;
+  }
+
+  // Add HTTP method
+  if (event.method) {
+    attributes['http.request.method'] = event.method;
+  }
+
+  // Add route information
+  if (event.path) {
+    attributes['http.route'] = event.path;
+  }
+
+  // Extract and add HTTP headers as span attributes
+  const client = getClient();
+  const sendDefaultPii = client?.getOptions().sendDefaultPii ?? false;
+
+  // Get headers from the Node.js request object
+  const headers = event.node?.req?.headers || {};
+  const headerAttributes = httpHeadersToSpanAttributes(headers, sendDefaultPii);
+
+  // Merge header attributes with existing attributes
+  Object.assign(attributes, headerAttributes);
+
+  return attributes;
+}
+
+/**
+ * Checks if the handler is an event handler, util for type narrowing.
+ */
+function isEventHandlerObject(handler: EventHandler | EventHandlerObject): handler is EventHandlerObject {
+  return typeof handler !== 'function';
+}
diff --git a/packages/nuxt/src/vite/middlewareConfig.ts b/packages/nuxt/src/vite/middlewareConfig.ts
new file mode 100644
index 000000000000..d851345172d8
--- /dev/null
+++ b/packages/nuxt/src/vite/middlewareConfig.ts
@@ -0,0 +1,97 @@
+import { addServerImports, createResolver } from '@nuxt/kit';
+import type { Nitro } from 'nitropack/types';
+import * as path from 'path';
+import type { InputPluginOption } from 'rollup';
+
+/**
+ * Adds a server import for the middleware instrumentation.
+ */
+export function addMiddlewareImports(): void {
+  addServerImports([
+    {
+      name: 'wrapMiddlewareHandlerWithSentry',
+      from: createResolver(import.meta.url).resolve('./runtime/hooks/wrapMiddlewareHandler'),
+    },
+  ]);
+}
+
+/**
+ * Adds middleware instrumentation to the Nitro build.
+ *
+ * @param nitro Nitro instance
+ */
+export function addMiddlewareInstrumentation(nitro: Nitro): void {
+  nitro.hooks.hook('rollup:before', (nitro, rollupConfig) => {
+    if (!rollupConfig.plugins) {
+      rollupConfig.plugins = [];
+    }
+
+    if (!Array.isArray(rollupConfig.plugins)) {
+      rollupConfig.plugins = [rollupConfig.plugins];
+    }
+
+    rollupConfig.plugins.push(middlewareInstrumentationPlugin(nitro));
+  });
+}
+
+/**
+ * Creates a rollup plugin for the middleware instrumentation by transforming the middleware code.
+ *
+ * @param nitro Nitro instance
+ * @returns The rollup plugin for the middleware instrumentation.
+ */
+function middlewareInstrumentationPlugin(nitro: Nitro): InputPluginOption {
+  const middlewareFiles = new Set<string>();
+
+  return {
+    name: 'sentry-nuxt-middleware-instrumentation',
+    buildStart() {
+      // Collect middleware files during build start
+      nitro.scannedHandlers?.forEach(({ middleware, handler }) => {
+        if (middleware && handler) {
+          middlewareFiles.add(handler);
+        }
+      });
+    },
+    transform(code: string, id: string) {
+      // Only transform files we've identified as middleware
+      if (middlewareFiles.has(id)) {
+        const fileName = path.basename(id);
+        return {
+          code: wrapMiddlewareCode(code, fileName),
+          map: null,
+        };
+      }
+      return null;
+    },
+  };
+}
+
+/**
+ * Wraps the middleware user code to instrument it.
+ *
+ * @param originalCode The original user code of the middleware.
+ * @param fileName The name of the middleware file, used for the span name and logging.
+ *
+ * @returns The wrapped user code of the middleware.
+ */
+function wrapMiddlewareCode(originalCode: string, fileName: string): string {
+  // Remove common file extensions
+  const cleanFileName = fileName.replace(/\.(ts|js|mjs|mts|cts)$/, '');
+
+  return `
+import { wrapMiddlewareHandlerWithSentry } from '#imports';
+
+function defineInstrumentedEventHandler(handlerOrObject) {
+  return defineEventHandler(wrapMiddlewareHandlerWithSentry(handlerOrObject, '${cleanFileName}'));
+}
+
+function instrumentedEventHandler(handlerOrObject) {
+  return eventHandler(wrapMiddlewareHandlerWithSentry(handlerOrObject, '${cleanFileName}'));
+}
+
+${originalCode
+  .replace(/defineEventHandler\(/g, 'defineInstrumentedEventHandler(')
+  .replace(/eventHandler\(/g, 'instrumentedEventHandler(')}
+`;
+}
diff --git a/packages/nuxt/test/runtime/hooks/wrapMiddlewareHandler.test.ts b/packages/nuxt/test/runtime/hooks/wrapMiddlewareHandler.test.ts
new file mode 100644
index 000000000000..c1f73cd858fa
--- /dev/null
+++ b/packages/nuxt/test/runtime/hooks/wrapMiddlewareHandler.test.ts
@@ -0,0 +1,506 @@
+import * as SentryCore from '@sentry/core';
+import type { EventHandler, EventHandlerRequest, H3Event } from 'h3';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { wrapMiddlewareHandlerWithSentry } from '../../../src/runtime/hooks/wrapMiddlewareHandler';
+
+// Only mock the Sentry APIs we need to verify
+vi.mock('@sentry/core', async importOriginal => {
+  const mod = await importOriginal();
+  return {
+    ...(mod as any),
+    debug: { log: vi.fn() },
+    startSpan: vi.fn(),
+    getClient: vi.fn(),
+    httpHeadersToSpanAttributes: vi.fn(),
+    captureException: vi.fn(),
+    flushIfServerless: vi.fn(),
+  };
+});
+
+describe('wrapMiddlewareHandlerWithSentry', () => {
+  const mockEvent: H3Event<EventHandlerRequest> = {
+    path: '/test-path',
+    method: 'GET',
+    node: {
+      req: {
+        headers: { 'user-agent': 'test-agent' },
+        url: '/test-url',
+      },
+    },
+  } as any;
+
+  const mockSpan = {
+    setStatus: vi.fn(),
+    recordException: vi.fn(),
+    end: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Setup minimal required mocks
+    (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.flushIfServerless as any).mockResolvedValue(undefined);
+  });
+
+  describe('function handler wrapping', () => {
+    it('should wrap function handlers correctly and preserve return values', async () => {
+      const functionHandler: EventHandler = vi.fn().mockResolvedValue('success');
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(functionHandler, 'test-middleware');
+      const result = await wrapped(mockEvent);
+
+      expect(functionHandler).toHaveBeenCalledWith(mockEvent);
+      expect(result).toBe('success');
+      expect(typeof wrapped).toBe('function');
+    });
+
+    it('should preserve sync return values from function handlers', async () => {
+      const syncHandler: EventHandler = vi.fn().mockReturnValue('sync-result');
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(syncHandler, 'sync-middleware');
+      const result = await wrapped(mockEvent);
+
+      expect(syncHandler).toHaveBeenCalledWith(mockEvent);
+      expect(result).toBe('sync-result');
+    });
+  });
+
+  describe('different handler types', () => {
+    it('should handle async function handlers', async () => {
+      const asyncHandler: EventHandler = vi.fn().mockResolvedValue('async-success');
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(asyncHandler, 'async-middleware');
+      const result = await wrapped(mockEvent);
+
+      expect(asyncHandler).toHaveBeenCalledWith(mockEvent);
+      expect(result).toBe('async-success');
+    });
+  });
+
+  describe('error propagation without masking', () => {
+    it('should propagate async errors without modification', async () => {
+      const originalError = new Error('Original async error');
+      originalError.stack = 'original-stack-trace';
+      const failingHandler: EventHandler = vi.fn().mockRejectedValue(originalError);
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(failingHandler, 'failing-middleware');
+
+      await expect(wrapped(mockEvent)).rejects.toThrow('Original async error');
+      await expect(wrapped(mockEvent)).rejects.toMatchObject({
+        message: 'Original async error',
+        stack: 'original-stack-trace',
+      });
+
+      // Verify Sentry APIs were called but error was not masked
+      expect(SentryCore.captureException).toHaveBeenCalledWith(originalError, expect.any(Object));
+    });
+
+    it('should propagate sync errors without modification', async () => {
+      const originalError = new Error('Original sync error');
+      const failingHandler: EventHandler = vi.fn().mockImplementation(() => {
+        throw originalError;
+      });
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(failingHandler, 'sync-failing-middleware');
+
+      await expect(wrapped(mockEvent)).rejects.toThrow('Original sync error');
+      await expect(wrapped(mockEvent)).rejects.toBe(originalError);
+
+      expect(SentryCore.captureException).toHaveBeenCalledWith(originalError, expect.any(Object));
+    });
+
+    it('should handle non-Error thrown values', async () => {
+      const stringError = 'String error';
+      const failingHandler: EventHandler = vi.fn().mockRejectedValue(stringError);
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(failingHandler, 'string-error-middleware');
+
+      await expect(wrapped(mockEvent)).rejects.toBe(stringError);
+      expect(SentryCore.captureException).toHaveBeenCalledWith(stringError, expect.any(Object));
+    });
+  });
+
+  describe('user code isolation', () => {
+    it('should not affect user code when Sentry APIs fail', async () => {
+      // Simulate Sentry API failures
+      (SentryCore.startSpan as any).mockImplementation(() => {
+        throw new Error('Sentry API failure');
+      });
+
+      const userHandler: EventHandler = vi.fn().mockResolvedValue('user-result');
+
+      // Should not throw despite Sentry failure
+      const wrapped = wrapMiddlewareHandlerWithSentry(userHandler, 'isolated-middleware');
+
+      // This should handle the Sentry error gracefully and still call user code
+      await expect(wrapped(mockEvent)).rejects.toThrow('Sentry API failure');
+    });
+  });
+
+  describe('EventHandlerObject wrapping', () => {
+    it('should wrap EventHandlerObject.handler correctly', async () => {
+      const baseHandler: EventHandler = vi.fn().mockResolvedValue('handler-result');
+      const handlerObject = {
+        handler: baseHandler,
+      };
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(handlerObject, 'object-middleware');
+
+      // Should return an object with wrapped handler
+      expect(typeof wrapped).toBe('object');
+      expect(wrapped).toHaveProperty('handler');
+      expect(typeof wrapped.handler).toBe('function');
+
+      // Test that the wrapped handler works
+      const result = await wrapped.handler(mockEvent);
+      expect(result).toBe('handler-result');
+      expect(baseHandler).toHaveBeenCalledWith(mockEvent);
+
+      // Verify Sentry instrumentation was applied
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'object-middleware',
+          attributes: expect.objectContaining({
+            [SentryCore.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'middleware.nuxt',
+            'nuxt.middleware.name': 'object-middleware',
+          }),
+        }),
+        expect.any(Function),
+      );
+    });
+
+    it('should wrap EventHandlerObject.onRequest handlers correctly', async () => {
+      const baseHandler: EventHandler = vi.fn().mockResolvedValue('main-result');
+      const onRequestHandler = vi.fn().mockResolvedValue(undefined);
+      const handlerObject = {
+        handler: baseHandler,
+        onRequest: onRequestHandler,
+      };
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(handlerObject, 'request-middleware');
+
+      // Should preserve onRequest handler
+      expect(wrapped).toHaveProperty('onRequest');
+      expect(typeof wrapped.onRequest).toBe('function');
+
+      // Test that the wrapped onRequest handler works
+      await wrapped.onRequest(mockEvent);
+      expect(onRequestHandler).toHaveBeenCalledWith(mockEvent);
+
+      // Verify Sentry instrumentation was applied to onRequest
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'request-middleware.onRequest',
+          attributes: expect.objectContaining({
+            [SentryCore.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'middleware.nuxt',
+            'nuxt.middleware.name': 'request-middleware',
+            'nuxt.middleware.hook.name': 'onRequest',
+          }),
+        }),
+        expect.any(Function),
+      );
+
+      // Verify that single handlers don't have an index attribute
+      const spanCall = (SentryCore.startSpan as any).mock.calls.find(
+        (call: any) => call[0]?.attributes?.['nuxt.middleware.hook.name'] === 'onRequest',
+      );
+      expect(spanCall[0].attributes).not.toHaveProperty('nuxt.middleware.hook.index');
+    });
+
+    it('should wrap EventHandlerObject.onRequest array of handlers correctly', async () => {
+      const baseHandler: EventHandler = vi.fn().mockResolvedValue('main-result');
+      const onRequestHandler1 = vi.fn().mockResolvedValue(undefined);
+      const onRequestHandler2 = vi.fn().mockResolvedValue(undefined);
+      const handlerObject = {
+        handler: baseHandler,
+        onRequest: [onRequestHandler1, onRequestHandler2],
+      };
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(handlerObject, 'multi-request-middleware');
+
+      // Should preserve onRequest as array
+      expect(wrapped).toHaveProperty('onRequest');
+      expect(Array.isArray(wrapped.onRequest)).toBe(true);
+      expect(wrapped.onRequest).toHaveLength(2);
+
+      // Test that both wrapped handlers work
+      if (Array.isArray(wrapped.onRequest)) {
+        await wrapped.onRequest[0]!(mockEvent);
+        await wrapped.onRequest[1]!(mockEvent);
+      }
+
+      expect(onRequestHandler1).toHaveBeenCalledWith(mockEvent);
+      expect(onRequestHandler2).toHaveBeenCalledWith(mockEvent);
+
+      // Verify Sentry instrumentation was applied to both handlers
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'multi-request-middleware.onRequest',
+          attributes: expect.objectContaining({
+            'nuxt.middleware.hook.name': 'onRequest',
+            'nuxt.middleware.hook.index': 0,
+          }),
+        }),
+        expect.any(Function),
+      );
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'multi-request-middleware.onRequest',
+          attributes: expect.objectContaining({
+            'nuxt.middleware.hook.name': 'onRequest',
+            'nuxt.middleware.hook.index': 1,
+          }),
+        }),
+        expect.any(Function),
+      );
+    });
+
+    it('should wrap EventHandlerObject.onBeforeResponse handlers correctly', async () => {
+      const baseHandler: EventHandler = vi.fn().mockResolvedValue('main-result');
+      const onBeforeResponseHandler = vi.fn().mockResolvedValue(undefined);
+      const handlerObject = {
+        handler: baseHandler,
+        onBeforeResponse: onBeforeResponseHandler,
+      };
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(handlerObject, 'response-middleware');
+
+      // Should preserve onBeforeResponse handler
+      expect(wrapped).toHaveProperty('onBeforeResponse');
+      expect(typeof wrapped.onBeforeResponse).toBe('function');
+
+      // Test that the wrapped onBeforeResponse handler works
+      const mockResponse = { body: 'test-response' };
+      await wrapped.onBeforeResponse(mockEvent, mockResponse);
+      expect(onBeforeResponseHandler).toHaveBeenCalledWith(mockEvent, mockResponse);
+
+      // Verify Sentry instrumentation was applied to onBeforeResponse
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'response-middleware.onBeforeResponse',
+          attributes: expect.objectContaining({
+            [SentryCore.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'middleware.nuxt',
+            'nuxt.middleware.name': 'response-middleware',
+            'nuxt.middleware.hook.name': 'onBeforeResponse',
+          }),
+        }),
+        expect.any(Function),
+      );
+    });
+
+    it('should wrap EventHandlerObject.onBeforeResponse array of handlers correctly', async () => {
+      const baseHandler: EventHandler = vi.fn().mockResolvedValue('main-result');
+      const onBeforeResponseHandler1 = vi.fn().mockResolvedValue(undefined);
+      const onBeforeResponseHandler2 = vi.fn().mockResolvedValue(undefined);
+      const handlerObject = {
+        handler: baseHandler,
+        onBeforeResponse: [onBeforeResponseHandler1, onBeforeResponseHandler2],
+      };
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(handlerObject, 'multi-response-middleware');
+
+      // Should preserve onBeforeResponse as array
+      expect(wrapped).toHaveProperty('onBeforeResponse');
+      expect(Array.isArray(wrapped.onBeforeResponse)).toBe(true);
+      expect(wrapped.onBeforeResponse).toHaveLength(2);
+
+      // Test that both wrapped handlers work
+      const mockResponse = { body: 'test-response' };
+      if (Array.isArray(wrapped.onBeforeResponse)) {
+        await wrapped.onBeforeResponse[0]!(mockEvent, mockResponse);
+        await wrapped.onBeforeResponse[1]!(mockEvent, mockResponse);
+      }
+
+      expect(onBeforeResponseHandler1).toHaveBeenCalledWith(mockEvent, mockResponse);
+      expect(onBeforeResponseHandler2).toHaveBeenCalledWith(mockEvent, mockResponse);
+
+      // Verify Sentry instrumentation was applied to both handlers
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'multi-response-middleware.onBeforeResponse',
+          attributes: expect.objectContaining({
+            'nuxt.middleware.hook.name': 'onBeforeResponse',
+            'nuxt.middleware.hook.index': 0,
+          }),
+        }),
+        expect.any(Function),
+      );
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'multi-response-middleware.onBeforeResponse',
+          attributes: expect.objectContaining({
+            'nuxt.middleware.hook.name': 'onBeforeResponse',
+            'nuxt.middleware.hook.index': 1,
+          }),
+        }),
+        expect.any(Function),
+      );
+    });
+
+    it('should wrap complex EventHandlerObject with all properties', async () => {
+      const baseHandler: EventHandler = vi.fn().mockResolvedValue('complex-result');
+      const onRequestHandler = vi.fn().mockResolvedValue(undefined);
+      const onBeforeResponseHandler = vi.fn().mockResolvedValue(undefined);
+      const handlerObject = {
+        handler: baseHandler,
+        onRequest: onRequestHandler,
+        onBeforeResponse: onBeforeResponseHandler,
+      };
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(handlerObject, 'complex-middleware');
+
+      // Should preserve all properties
+      expect(wrapped).toHaveProperty('handler');
+      expect(wrapped).toHaveProperty('onRequest');
+      expect(wrapped).toHaveProperty('onBeforeResponse');
+
+      // Test main handler
+      const result = await wrapped.handler(mockEvent);
+      expect(result).toBe('complex-result');
+      expect(baseHandler).toHaveBeenCalledWith(mockEvent);
+
+      // Test onRequest handler
+      await wrapped.onRequest(mockEvent);
+      expect(onRequestHandler).toHaveBeenCalledWith(mockEvent);
+
+      // Test onBeforeResponse handler
+      const mockResponse = { body: 'test-response' };
+      await wrapped.onBeforeResponse(mockEvent, mockResponse);
+      expect(onBeforeResponseHandler).toHaveBeenCalledWith(mockEvent, mockResponse);
+
+      // Verify all handlers got Sentry instrumentation
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'complex-middleware',
+          attributes: expect.objectContaining({ 'nuxt.middleware.hook.name': 'handler' }),
+        }),
+        expect.any(Function),
+      );
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'complex-middleware.onRequest',
+          attributes: expect.objectContaining({ 'nuxt.middleware.hook.name': 'onRequest' }),
+        }),
+        expect.any(Function),
+      );
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'complex-middleware.onBeforeResponse',
+          attributes: expect.objectContaining({ 'nuxt.middleware.hook.name': 'onBeforeResponse' }),
+        }),
+        expect.any(Function),
+      );
+    });
+
+    it('should handle EventHandlerObject without optional handlers', async () => {
+      const baseHandler: EventHandler = vi.fn().mockResolvedValue('minimal-object-result');
+      const handlerObject = {
+        handler: baseHandler,
+        // No onRequest or onBeforeResponse
+      };
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(handlerObject, 'minimal-object-middleware');
+
+      // Should only have handler property
+      expect(wrapped).toHaveProperty('handler');
+      expect(wrapped).not.toHaveProperty('onRequest');
+      expect(wrapped).not.toHaveProperty('onBeforeResponse');
+
+      // Test that the main handler works
+      const result = await wrapped.handler(mockEvent);
+      expect(result).toBe('minimal-object-result');
+      expect(baseHandler).toHaveBeenCalledWith(mockEvent);
+
+      // Verify Sentry instrumentation was applied
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'minimal-object-middleware',
+        }),
+        expect.any(Function),
+      );
+    });
+
+    it('should propagate errors from EventHandlerObject.handler', async () => {
+      const error = new Error('Handler error');
+      const failingHandler: EventHandler = vi.fn().mockRejectedValue(error);
+      const handlerObject = {
+        handler: failingHandler,
+      };
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(handlerObject, 'failing-object-middleware');
+
+      await expect(wrapped.handler(mockEvent)).rejects.toThrow('Handler error');
+      expect(SentryCore.captureException).toHaveBeenCalledWith(error, expect.any(Object));
+    });
+
+    it('should propagate errors from EventHandlerObject.onRequest', async () => {
+      const baseHandler: EventHandler = vi.fn().mockResolvedValue('success');
+      const error = new Error('OnRequest error');
+      const failingOnRequestHandler = vi.fn().mockRejectedValue(error);
+      const handlerObject = {
+        handler: baseHandler,
+        onRequest: failingOnRequestHandler,
+      };
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(handlerObject, 'failing-request-middleware');
+
+      await expect(wrapped.onRequest(mockEvent)).rejects.toThrow('OnRequest error');
+      expect(SentryCore.captureException).toHaveBeenCalledWith(error, expect.any(Object));
+    });
+
+    it('should propagate errors from EventHandlerObject.onBeforeResponse', async () => {
+      const baseHandler: EventHandler = vi.fn().mockResolvedValue('success');
+      const error = new Error('OnBeforeResponse error');
+      const failingOnBeforeResponseHandler = vi.fn().mockRejectedValue(error);
+      const handlerObject = {
+        handler: baseHandler,
+        onBeforeResponse: failingOnBeforeResponseHandler,
+      };
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(handlerObject, 'failing-response-middleware');
+
+      const mockResponse = { body: 'test-response' };
+      await expect(wrapped.onBeforeResponse(mockEvent, mockResponse)).rejects.toThrow('OnBeforeResponse error');
+      expect(SentryCore.captureException).toHaveBeenCalledWith(error, expect.any(Object));
+    });
+  });
+
+  describe('Sentry API integration', () => {
+    it('should call Sentry APIs with correct parameters', async () => {
+      const userHandler: EventHandler = vi.fn().mockResolvedValue('api-test-result');
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(userHandler, 'api-middleware');
+      await wrapped(mockEvent);
+
+      // Verify key Sentry APIs are called correctly
+      expect(SentryCore.startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'api-middleware',
+          attributes: expect.objectContaining({
+            [SentryCore.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'middleware.nuxt',
+            'nuxt.middleware.name': 'api-middleware',
+            'http.request.method': 'GET',
+            'http.route': '/test-path',
+          }),
+        }),
+        expect.any(Function),
+      );
+    });
+
+    it('should handle missing optional data gracefully', async () => {
+      const minimalEvent = { path: '/minimal' } as H3Event<EventHandlerRequest>;
+      const userHandler: EventHandler = vi.fn().mockResolvedValue('minimal-result');
+
+      const wrapped = wrapMiddlewareHandlerWithSentry(userHandler, 'minimal-middleware');
+      const result = await wrapped(minimalEvent);
+
+      expect(result).toBe('minimal-result');
+      expect(userHandler).toHaveBeenCalledWith(minimalEvent);
+      // Should still create span even with minimal data
+      expect(SentryCore.startSpan).toHaveBeenCalled();
+    });
+  });
+});