fix(hono): Use arity heuristic to distinguish .use() middleware from .all() handlers

Hono registers both .use() middleware and .all() route handlers with
method:'ALL' internally. Previously patchRoute wrapped all method:'ALL'
handlers as middleware spans, incorrectly tracing .all() final handlers.

Use handler.length >= 2 (accepts context + next) to identify middleware
vs handler.length < 2 (accepts only context) for route handlers.

Also guard responseHandler against re-capturing errors already captured
by wrapMiddlewareWithSpan via isAlreadyCaptured check.

Made-with: Cursor

Author: s1gr1d

packages/hono/src/shared/middlewareHandlers.ts

@@ -4,6 +4,7 @@ import {
   getDefaultIsolationScope,
   getIsolationScope,
   getRootSpan,
+  isAlreadyCaptured,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
   updateSpanName,
   winterCGRequestToRequestData,
@@ -42,7 +43,7 @@ export function responseHandler(context: Context): void {
 
   getIsolationScope().setTransactionName(`${context.req.method} ${routePath(context)}`);
 
-  if (context.error) {
+  if (context.error && !isAlreadyCaptured(context.error)) {
     getClient()?.captureException(context.error, {
       mechanism: { handled: false, type: 'auto.http.hono.context_error' },
     });

packages/hono/src/shared/patchRoute.ts

@@ -1,8 +1,14 @@
 import { getOriginalFunction, markFunctionWrapped } from '@sentry/core';
 import type { WrappedFunction } from '@sentry/core';
-import type { Env, Hono } from 'hono';
+import type { Env, Hono, MiddlewareHandler } from 'hono';
 import { wrapMiddlewareWithSpan } from './wrapMiddlewareSpan';
 
+interface HonoRoute {
+  method: string;
+  path: string;
+  handler: MiddlewareHandler;
+}
+
 interface HonoBaseProto {
   // oxlint-disable-next-line typescript/no-explicit-any
   route: (path: string, app: Hono<any>) => Hono<any>;
@@ -29,19 +35,47 @@ export function patchRoute<E extends Env>(app: Hono<E>): void {
   // oxlint-disable-next-line typescript/no-explicit-any
   const patchedRoute = function (this: Hono<any>, path: string, subApp: Hono<any>): Hono<any> {
     if (subApp && Array.isArray(subApp.routes)) {
-      for (const route of subApp.routes) {
-        /* Internally, `app.use()` always registers with `method: 'ALL'` (via the constant `METHOD_NAME_ALL`),
-         * while `app.get()` / `.post()` / etc. use their respective uppercase method name.
-         * https://github.com/honojs/hono/blob/18fe604c8cefc2628240651b1af219692e1918c1/src/hono-base.ts#L156-L168
-         */
-        if (route.method === 'ALL' && typeof route.handler === 'function') {
-          route.handler = wrapMiddlewareWithSpan(route.handler);
-        }
-      }
+      wrapSubAppMiddleware(subApp.routes as HonoRoute[]);
     }
     return originalRoute.call(this, path, subApp);
   };
 
   markFunctionWrapped(patchedRoute as unknown as WrappedFunction, originalRoute as unknown as WrappedFunction);
   honoBaseProto.route = patchedRoute;
 }
+
+/**
+ * Wraps middleware handlers in a sub-app's routes array with Sentry spans.
+ *
+ * When multiple handlers share the same method+path (e.g. `app.get('/path', mw, handler)`),
+ * Hono registers each as a separate route entry. We wrap all but the last entry per group
+ * (those are the middleware), leaving the final handler unwrapped.
+ *
+ * For `method: 'ALL'` handlers that are last-for-group (from `.use()` or `.all()`),
+ * we use an arity (# of params) heuristic: middleware takes `(context, next)` (length >= 2),
+ * while final handlers take only `(context)` (length < 2). This distinguishes
+ * `.use()` middleware (should be traced) from `.all()` route handlers (should not).
+ *
+ * Hono's .use() and .all() both register as method 'ALL', but .use() middleware
+ * always accepts (context, next) while .all() handlers typically accept only (context).
+ * https://github.com/honojs/hono/blob/18fe604c8cefc2628240651b1af219692e1918c1/src/hono-base.ts#L156-L168
+ */
+function wrapSubAppMiddleware(routes: HonoRoute[]): void {
+  const lastIndexByKey = new Map<string, number>();
+  for (const [i, route] of routes.entries()) {
+    lastIndexByKey.set(`${route.method}\0${route.path}`, i);
+  }
+
+  for (const [i, route] of routes.entries()) {
+    if (typeof route.handler !== 'function') {
+      continue;
+    }
+
+    const isLastForGroup = lastIndexByKey.get(`${route.method}\0${route.path}`) === i;
+
+    const isMiddleware = !isLastForGroup || (route.method === 'ALL' && route.handler.length >= 2);
+    if (isMiddleware) {
+      route.handler = wrapMiddlewareWithSpan(route.handler);
+    }
+  }
+}