fix(cloudflare): Capture exceptions thrown in hono (#16355)

Our cloudflare SDK captures fetch exceptions in the catch block. But
hono never reaches [this
block](https://github.com/getsentry/sentry-javascript/blob/a874d763171289b5556973a4842f580d4bbb7ec0/packages/cloudflare/src/request.ts#L85-L90)
where we send exceptions.
hono processes errors with their `onError` function (or `errorHandler`)
and we need to capture the exception there.

This PR wraps the [`errorHandler` of
hono](https://github.com/honojs/hono/blob/bb7afaccfd5b6b514da356e069f27eb5ccfc0e3b/src/hono-base.ts#L36
).

Will create an E2E test in another PR.

Author: s1gr1d

packages/cloudflare/src/handler.ts

@@ -26,6 +26,7 @@ import { init } from './sdk';
  * @param handler {ExportedHandler} The handler to wrap.
  * @returns The wrapped handler.
  */
+// eslint-disable-next-line complexity
 export function withSentry<Env = unknown, QueueHandlerMessage = unknown, CfHostMetadata = unknown>(
   optionsCallback: (env: Env) => CloudflareOptions,
   handler: ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata>,
@@ -47,6 +48,26 @@ export function withSentry<Env = unknown, QueueHandlerMessage = unknown, CfHostM
       markAsInstrumented(handler.fetch);
     }
 
+    /* hono does not reach the catch block of the fetch handler and captureException needs to be called in the hono errorHandler */
+    if (
+      'onError' in handler &&
+      'errorHandler' in handler &&
+      typeof handler.errorHandler === 'function' &&
+      !isInstrumented(handler.errorHandler)
+    ) {
+      handler.errorHandler = new Proxy(handler.errorHandler, {
+        apply(target, thisArg, args) {
+          const [err] = args;
+
+          captureException(err, { mechanism: { handled: false, type: 'cloudflare' } });
+
+          return Reflect.apply(target, thisArg, args);
+        },
+      });
+
+      markAsInstrumented(handler.errorHandler);
+    }
+
     if ('scheduled' in handler && typeof handler.scheduled === 'function' && !isInstrumented(handler.scheduled)) {
       handler.scheduled = new Proxy(handler.scheduled, {
         apply(target, thisArg, args: Parameters<ExportedHandlerScheduledHandler<Env>>) {

packages/cloudflare/test/handler.test.ts

@@ -7,6 +7,17 @@ import * as SentryCore from '@sentry/core';
 import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { CloudflareClient } from '../src/client';
 import { withSentry } from '../src/handler';
+import { markAsInstrumented } from '../src/instrument';
+
+// Custom type for hono-like apps (cloudflare handlers) that include errorHandler and onError
+type HonoLikeApp<Env = unknown, QueueHandlerMessage = unknown, CfHostMetadata = unknown> = ExportedHandler<
+  Env,
+  QueueHandlerMessage,
+  CfHostMetadata
+> & {
+  onError?: () => void;
+  errorHandler?: (err: Error) => Response;
+};
 
 const MOCK_ENV = {
   SENTRY_DSN: 'https://[email protected]/1337',
@@ -931,6 +942,86 @@ describe('withSentry', () => {
       });
     });
   });
+
+  describe('hono errorHandler', () => {
+    test('captures errors handled by the errorHandler', async () => {
+      const captureExceptionSpy = vi.spyOn(SentryCore, 'captureException');
+      const error = new Error('test hono error');
+
+      const honoApp = {
+        fetch(_request, _env, _context) {
+          return new Response('test');
+        },
+        onError() {}, // hono-like onError
+        errorHandler(err: Error) {
+          return new Response(`Error: ${err.message}`, { status: 500 });
+        },
+      } satisfies HonoLikeApp<typeof MOCK_ENV>;
+
+      withSentry(env => ({ dsn: env.SENTRY_DSN }), honoApp);
+
+      // simulates hono's error handling
+      const errorHandlerResponse = honoApp.errorHandler?.(error);
+
+      expect(captureExceptionSpy).toHaveBeenCalledTimes(1);
+      expect(captureExceptionSpy).toHaveBeenLastCalledWith(error, {
+        mechanism: { handled: false, type: 'cloudflare' },
+      });
+      expect(errorHandlerResponse?.status).toBe(500);
+    });
+
+    test('preserves the original errorHandler functionality', async () => {
+      const originalErrorHandlerSpy = vi.fn().mockImplementation((err: Error) => {
+        return new Response(`Error: ${err.message}`, { status: 500 });
+      });
+
+      const error = new Error('test hono error');
+
+      const honoApp = {
+        fetch(_request, _env, _context) {
+          return new Response('test');
+        },
+        onError() {}, // hono-like onError
+        errorHandler: originalErrorHandlerSpy,
+      } satisfies HonoLikeApp<typeof MOCK_ENV>;
+
+      withSentry(env => ({ dsn: env.SENTRY_DSN }), honoApp);
+
+      // Call the errorHandler directly to simulate Hono's error handling
+      const errorHandlerResponse = honoApp.errorHandler?.(error);
+
+      expect(originalErrorHandlerSpy).toHaveBeenCalledTimes(1);
+      expect(originalErrorHandlerSpy).toHaveBeenLastCalledWith(error);
+      expect(errorHandlerResponse?.status).toBe(500);
+    });
+
+    test('does not instrument an already instrumented errorHandler', async () => {
+      const captureExceptionSpy = vi.spyOn(SentryCore, 'captureException');
+      const error = new Error('test hono error');
+
+      // Create a handler with an errorHandler that's already been instrumented
+      const originalErrorHandler = (err: Error) => {
+        return new Response(`Error: ${err.message}`, { status: 500 });
+      };
+
+      // Mark as instrumented before wrapping
+      markAsInstrumented(originalErrorHandler);
+
+      const honoApp = {
+        fetch(_request, _env, _context) {
+          return new Response('test');
+        },
+        onError() {}, // hono-like onError
+        errorHandler: originalErrorHandler,
+      } satisfies HonoLikeApp<typeof MOCK_ENV>;
+
+      withSentry(env => ({ dsn: env.SENTRY_DSN }), honoApp);
+
+      // The errorHandler should not have been wrapped again
+      honoApp.errorHandler?.(error);
+      expect(captureExceptionSpy).not.toHaveBeenCalled();
+    });
+  });
 });
 
 function createMockExecutionContext(): ExecutionContext {