feat(hono): Instrument middlewares app.use()

dev-packages/cloudflare-integration-tests/suites/hono-sdk/index.ts

@@ -12,9 +12,6 @@ app.use(
   sentry(app, {
     dsn: process.env.SENTRY_DSN,
     tracesSampleRate: 1.0,
-    debug: true,
-    // fixme - check out what removing this integration changes
-    // integrations: integrations => integrations.filter(integration => integration.name !== 'Hono'),
   }),
 );
 
@@ -26,7 +23,7 @@ app.get('/json', c => {
   return c.json({ message: 'Hello from Hono', framework: 'hono', platform: 'cloudflare' });
 });
 
-app.get('/error', () => {
+app.get('/error/:param', () => {
   throw new Error('Test error from Hono app');
 });
 

dev-packages/cloudflare-integration-tests/suites/hono-sdk/test.ts

@@ -2,13 +2,13 @@ import { expect, it } from 'vitest';
 import { eventEnvelope, SHORT_UUID_MATCHER, UUID_MATCHER } from '../../expect';
 import { createRunner } from '../../runner';
 
-it('Hono app captures errors (Hono SDK)', async ({ signal }) => {
+it('Hono app captures parametrized errors (Hono SDK)', async ({ signal }) => {
   const runner = createRunner(__dirname)
     .expect(
       eventEnvelope(
         {
           level: 'error',
-          transaction: 'GET /error',
+          transaction: 'GET /error/:param',
           exception: {
             values: [
               {
@@ -24,12 +24,25 @@ it('Hono app captures errors (Hono SDK)', async ({ signal }) => {
           request: {
             headers: expect.any(Object),
             method: 'GET',
-            url: expect.any(String),
+            url: expect.stringContaining('/error/param-123'),
           },
+          breadcrumbs: [
+            {
+              timestamp: expect.any(Number),
+              category: 'console',
+              level: 'error',
+              message: 'Error: Test error from Hono app',
+              data: expect.objectContaining({
+                logger: 'console',
+                arguments: [{ message: 'Test error from Hono app', name: 'Error', stack: expect.any(String) }],
+              }),
+            },
+          ],
         },
         { includeSampleRand: true, sdk: 'hono' },
       ),
     )
+
     .expect(envelope => {
       const [, envelopeItems] = envelope;
       const [itemHeader, itemPayload] = envelopeItems[0];
@@ -39,7 +52,7 @@ it('Hono app captures errors (Hono SDK)', async ({ signal }) => {
       expect(itemPayload).toMatchObject({
         type: 'transaction',
         platform: 'javascript',
-        transaction: 'GET /error',
+        transaction: 'GET /error/:param',
         contexts: {
           trace: {
             span_id: expect.any(String),
@@ -51,15 +64,26 @@ it('Hono app captures errors (Hono SDK)', async ({ signal }) => {
         },
         request: expect.objectContaining({
           method: 'GET',
-          url: expect.stringContaining('/error'),
+          url: expect.stringContaining('/error/param-123'),
         }),
+        breadcrumbs: [
+          {
+            timestamp: expect.any(Number),
+            category: 'console',
+            level: 'error',
+            message: 'Error: Test error from Hono app',
+            data: expect.objectContaining({
+              logger: 'console',
+              arguments: [{ message: 'Test error from Hono app', name: 'Error', stack: expect.any(String) }],
+            }),
+          },
+        ],
       });
     })
-
     .unordered()
     .start(signal);
 
-  await runner.makeRequest('get', '/error', { expectError: true });
+  await runner.makeRequest('get', '/error/param-123', { expectError: true });
   await runner.completed();
 });
 

packages/hono/src/cloudflare/middleware.ts

@@ -1,19 +1,38 @@
 import { withSentry } from '@sentry/cloudflare';
-import { applySdkMetadata, type BaseTransportOptions, debug, type Options } from '@sentry/core';
+import { applySdkMetadata, type BaseTransportOptions, debug, type Integration, type Options } from '@sentry/core';
 import type { Context, Hono, MiddlewareHandler } from 'hono';
 import { requestHandler, responseHandler } from '../shared/middlewareHandlers';
+import { patchAppUse } from '../shared/patchAppUse';
 
 export interface HonoOptions extends Options<BaseTransportOptions> {
   context?: Context;
 }
 
+const filterHonoIntegration = (integration: Integration): boolean => integration.name !== 'Hono';
+
 export const sentry = (app: Hono, options: HonoOptions | undefined = {}): MiddlewareHandler => {
   const isDebug = options.debug;
 
   isDebug && debug.log('Initialized Sentry Hono middleware (Cloudflare)');
 
   applySdkMetadata(options, 'hono');
-  withSentry(() => options, app);
+
+  const { integrations: userIntegrations } = options;
+  withSentry(
+    () => ({
+      ...options,
+      // Always filter out the Hono integration from user-provided integrations (or when nothing is specified).
+      // The Hono integration is already set up by withSentry, so adding it again would cause double-capturing (and non-parametrized URLs).
+      integrations: Array.isArray(userIntegrations)
+        ? defaults => [...defaults.filter(filterHonoIntegration), ...userIntegrations.filter(filterHonoIntegration)]
+        : typeof userIntegrations === 'function'
+          ? defaults => userIntegrations(defaults).filter(filterHonoIntegration)
+          : defaults => defaults.filter(filterHonoIntegration),
+    }),
+    app,
+  );
+
+  patchAppUse(app);
 
   return async (context, next) => {
     requestHandler(context);

packages/hono/src/shared/middlewareHandlers.ts

@@ -38,6 +38,8 @@ export function responseHandler(context: Context): void {
   getIsolationScope().setTransactionName(`${context.req.method} ${routePath(context)}`);
 
   if (context.error) {
-    getClient()?.captureException(context.error);
+    getClient()?.captureException(context.error, {
+      mechanism: { handled: false, type: 'auto.faas.hono.error_handler' },
+    });
   }
 }

packages/hono/src/shared/patchAppUse.ts

@@ -0,0 +1,71 @@
+import {
+  captureException,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  SPAN_STATUS_ERROR,
+  SPAN_STATUS_OK,
+  startInactiveSpan,
+} from '@sentry/core';
+import type { Hono, MiddlewareHandler } from 'hono';
+
+const MIDDLEWARE_ORIGIN = 'auto.middleware.hono';
+
+// Module-level counter for anonymous middleware span names
+let MIDDLEWARE_IDX = 0;
+
+/**
+ * Patches `app.use` so that every middleware registered through it is automatically
+ * wrapped in a Sentry span. Supports both forms: `app.use(...handlers)` and `app.use(path, ...handlers)`.
+ */
+export function patchAppUse(app: Hono): void {
+  app.use = new Proxy(app.use, {
+    apply(target: typeof app.use, thisArg: typeof app, args: Parameters<typeof app.use>): ReturnType<typeof app.use> {
+      const [first, ...rest] = args as [unknown, ...MiddlewareHandler[]];
+
+      if (typeof first === 'string') {
+        const wrappedHandlers = rest.map(handler => wrapMiddlewareWithSpan(handler, MIDDLEWARE_IDX++));
+        return Reflect.apply(target, thisArg, [first, ...wrappedHandlers]);
+      }
+
+      const allHandlers = [first as MiddlewareHandler, ...rest].map(handler =>
+        wrapMiddlewareWithSpan(handler, MIDDLEWARE_IDX++),
+      );
+      return Reflect.apply(target, thisArg, allHandlers);
+    },
+  });
+}
+
+/**
+ * Wraps a Hono middleware handler so that its execution is traced as a Sentry span.
+ * Uses startInactiveSpan so that all middleware spans are siblings under the request/transaction
+ * (onion order: A → B → handler → B → A does not nest B under A in the trace).
+ */
+function wrapMiddlewareWithSpan(handler: MiddlewareHandler, index: number): MiddlewareHandler {
+  const spanName = handler.name || `<anonymous.${index}>`;
+
+  return async function sentryTracedMiddleware(context, next) {
+    const span = startInactiveSpan({
+      name: spanName,
+      op: 'middleware.hono',
+      onlyIfParent: true,
+      attributes: {
+        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'middleware.hono',
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: MIDDLEWARE_ORIGIN,
+      },
+    });
+
+    try {
+      const result = await handler(context, next);
+      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: MIDDLEWARE_ORIGIN },
+      });
+      throw error;
+    } finally {
+      span.end();
+    }
+  };
+}

packages/hono/test/cloudflare/middleware.test.ts

@@ -125,4 +125,81 @@ describe('Hono Cloudflare Middleware', () => {
       expect(middleware.constructor.name).toBe('AsyncFunction');
     });
   });
+
+  describe('filters Hono integration from user-provided integrations', () => {
+    const honoIntegration = { name: 'Hono' } as SentryCore.Integration;
+    const otherIntegration = { name: 'Other' } as SentryCore.Integration;
+
+    const getIntegrationsResult = () => {
+      const optionsCallback = withSentryMock.mock.calls[0]?.[0];
+      return optionsCallback().integrations;
+    };
+
+    it.each([
+      ['filters Hono integration out', [honoIntegration, otherIntegration], [otherIntegration]],
+      ['keeps non-Hono integrations', [otherIntegration], [otherIntegration]],
+      ['returns empty array when only Hono integration provided', [honoIntegration], []],
+    ])('%s (array)', (_name, input, expected) => {
+      const app = new Hono();
+      sentry(app, { integrations: input });
+
+      const integrationsFn = getIntegrationsResult() as (defaults: SentryCore.Integration[]) => SentryCore.Integration[];
+      expect(integrationsFn([])).toEqual(expected);
+    });
+
+    it('filters Hono from defaults when user provides an array', () => {
+      const app = new Hono();
+      sentry(app, { integrations: [otherIntegration] });
+
+      const integrationsFn = getIntegrationsResult() as (defaults: SentryCore.Integration[]) => SentryCore.Integration[];
+      // Simulates getIntegrationsToSetup: defaults (from Cloudflare) include Hono; result must exclude it
+      const defaultsWithHono = [honoIntegration, otherIntegration];
+      expect(integrationsFn(defaultsWithHono)).toEqual([otherIntegration, otherIntegration]);
+    });
+
+    it('filters Hono integration out of a function result', () => {
+      const app = new Hono();
+      sentry(app, { integrations: () => [honoIntegration, otherIntegration] });
+
+      const integrationsFn = getIntegrationsResult() as unknown as (
+        defaults: SentryCore.Integration[],
+      ) => SentryCore.Integration[];
+      expect(integrationsFn([])).toEqual([otherIntegration]);
+    });
+
+    it('passes defaults through to the user-provided integrations function', () => {
+      const app = new Hono();
+      const userFn = vi.fn((_defaults: SentryCore.Integration[]) => [otherIntegration]);
+      const defaults = [{ name: 'Default' } as SentryCore.Integration];
+
+      sentry(app, { integrations: userFn });
+
+      const integrationsFn = getIntegrationsResult() as unknown as (
+        defaults: SentryCore.Integration[],
+      ) => SentryCore.Integration[];
+      integrationsFn(defaults);
+
+      expect(userFn).toHaveBeenCalledWith(defaults);
+    });
+
+    it('filters Hono integration returned by the user-provided integrations function', () => {
+      const app = new Hono();
+      sentry(app, { integrations: (_defaults: SentryCore.Integration[]) => [honoIntegration] });
+
+      const integrationsFn = getIntegrationsResult() as unknown as (
+        defaults: SentryCore.Integration[],
+      ) => SentryCore.Integration[];
+      expect(integrationsFn([])).toEqual([]);
+    });
+
+    it('filters Hono integration from defaults when integrations is undefined', () => {
+      const app = new Hono();
+      sentry(app, {});
+
+      const integrationsFn = getIntegrationsResult() as unknown as (
+        defaults: SentryCore.Integration[],
+      ) => SentryCore.Integration[];
+      expect(integrationsFn([honoIntegration, otherIntegration])).toEqual([otherIntegration]);
+    });
+  });
 });