feat(hono): Use parametrized names for errors (#19577)

The SDK now only uses the hono integration for error capturing. Before,
the Hono integration from the Cloudflare SDK wrapping was used which
caused unparametrized transaction names.

Addtionally, the mechanism `auto.faas.hono.error_handler` was added to
the error.

Closes #19578 (added automatically)

Author: s1gr1d

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,46 @@
 import { withSentry } from '@sentry/cloudflare';
-import { applySdkMetadata, type BaseTransportOptions, debug, type Options } from '@sentry/core';
+import {
+  applySdkMetadata,
+  type BaseTransportOptions,
+  debug,
+  getIntegrationsToSetup,
+  type Integration,
+  type Options,
+} from '@sentry/core';
 import type { Context, Hono, MiddlewareHandler } from 'hono';
 import { requestHandler, responseHandler } from '../shared/middlewareHandlers';
 
 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 defaults and user integrations.
+      // The Hono integration is already set up by withSentry, so adding it again would cause capturing too early (in Cloudflare SDK) and non-parametrized URLs.
+      integrations: Array.isArray(userIntegrations)
+        ? defaults =>
+            getIntegrationsToSetup({
+              defaultIntegrations: defaults.filter(filterHonoIntegration),
+              integrations: userIntegrations.filter(filterHonoIntegration),
+            })
+        : typeof userIntegrations === 'function'
+          ? defaults => userIntegrations(defaults).filter(filterHonoIntegration)
+          : defaults => defaults.filter(filterHonoIntegration),
+    }),
+    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/test/cloudflare/middleware.test.ts

@@ -125,4 +125,102 @@ 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[];
+      // Defaults (from Cloudflare) include Hono; result must exclude it and deduplicate (user + defaults overlap)
+      const defaultsWithHono = [honoIntegration, otherIntegration];
+      expect(integrationsFn(defaultsWithHono)).toEqual([otherIntegration]);
+    });
+
+    it('deduplicates when user integrations overlap with defaults (by name)', () => {
+      const app = new Hono();
+      const duplicateIntegration = { name: 'Other' } as SentryCore.Integration;
+      sentry(app, { integrations: [duplicateIntegration] });
+
+      const integrationsFn = getIntegrationsResult() as (
+        defaults: SentryCore.Integration[],
+      ) => SentryCore.Integration[];
+      const defaultsWithOverlap = [
+        honoIntegration,
+        otherIntegration, // same name as duplicateIntegration
+      ];
+      const result = integrationsFn(defaultsWithOverlap);
+      expect(result).toHaveLength(1);
+      expect(result[0]?.name).toBe('Other');
+    });
+
+    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]);
+    });
+  });
 });