only increment on anonymous middleware

Author: s1gr1d

packages/hono/src/shared/patchAppUse.ts

@@ -22,13 +22,15 @@ export function patchAppUse(app: Hono): void {
     apply(target: typeof app.use, thisArg: typeof app, args: Parameters<typeof app.use>): ReturnType<typeof app.use> {
       const [first, ...rest] = args as [unknown, ...MiddlewareHandler[]];
 
+      const getSpanName = (handler: MiddlewareHandler): string => handler.name || `<anonymous.${MIDDLEWARE_IDX++}>`;
+
       if (typeof first === 'string') {
-        const wrappedHandlers = rest.map(handler => wrapMiddlewareWithSpan(handler, MIDDLEWARE_IDX++));
+        const wrappedHandlers = rest.map(handler => wrapMiddlewareWithSpan(handler, getSpanName(handler)));
         return Reflect.apply(target, thisArg, [first, ...wrappedHandlers]);
       }
 
       const allHandlers = [first as MiddlewareHandler, ...rest].map(handler =>
-        wrapMiddlewareWithSpan(handler, MIDDLEWARE_IDX++),
+        wrapMiddlewareWithSpan(handler, getSpanName(handler)),
       );
       return Reflect.apply(target, thisArg, allHandlers);
     },
@@ -40,9 +42,7 @@ export function patchAppUse(app: Hono): void {
  * 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}>`;
-
+function wrapMiddlewareWithSpan(handler: MiddlewareHandler, spanName: string): MiddlewareHandler {
   return async function sentryTracedMiddleware(context, next) {
     const span = startInactiveSpan({
       name: spanName,

packages/hono/test/shared/patchAppUse.test.ts

@@ -112,22 +112,29 @@ describe('patchAppUse (middleware spans)', () => {
   });
 
   it('creates sibling spans for multiple middlewares (onion order, not parent-child)', async () => {
+    vi.resetModules(); // resets the module-level counter variable
+    const { patchAppUse } = await import('../../src/shared/patchAppUse');
+
     const app = new Hono();
     patchAppUse(app);
 
     app.use(
       async (_c: unknown, next: () => Promise<void>) => next(),
+      async function namedMiddleware(_c: unknown, next: () => Promise<void>) {
+        await next();
+      },
       async (_c: unknown, next: () => Promise<void>) => next(),
     );
 
     await app.fetch(new Request('http://localhost/'));
 
-    expect(startInactiveSpanMock).toHaveBeenCalledTimes(2);
-    const [firstCall, secondCall] = startInactiveSpanMock.mock.calls;
+    expect(startInactiveSpanMock).toHaveBeenCalledTimes(3);
+    const [firstCall, secondCall, thirdCall] = startInactiveSpanMock.mock.calls;
     expect(firstCall[0]).toMatchObject({ op: 'middleware.hono' });
     expect(secondCall[0]).toMatchObject({ op: 'middleware.hono' });
-    expect(firstCall[0].name).toMatch(/^<anonymous\.\d+>$/);
-    expect(secondCall[0].name).toMatch(/^<anonymous\.\d+>$/);
+    expect(firstCall[0].name).toMatch('<anonymous.0>');
+    expect(secondCall[0].name).toBe('namedMiddleware');
+    expect(thirdCall[0].name).toBe('<anonymous.1>');
     expect(firstCall[0].name).not.toBe(secondCall[0].name);
   });