feat(hono): Instrument main-app inline middleware spans

dev-packages/e2e-tests/test-applications/hono-4/src/routes.ts

@@ -44,6 +44,39 @@ export function addRoutes(app: HonoType<{ Bindings?: { E2E_TEST_DSN: string } }>
   // Inline middleware patterns: direct method, .all(), .on() with inline/separate middleware
   app.route('/test-inline-middleware', subAppWithInlineMiddleware);
 
+  // Inline middleware on the main app via HTTP method registration (not .use()).
+  app.get(
+    '/test-main-inline/get',
+    async function mainInlineGet(_c, next) {
+      await next();
+    },
+    c => c.text('main inline get'),
+  );
+  app.post(
+    '/test-main-inline/post',
+    async function mainInlinePost(_c, next) {
+      await next();
+    },
+    c => c.text('main inline post'),
+  );
+  app.all(
+    '/test-main-inline/all',
+    async function mainInlineAll(_c, next) {
+      await next();
+    },
+    c => c.text('main inline all'),
+  );
+
+  // Combined: .use() middleware + inline middleware via .get() on the same path.
+  app.use('/test-main-inline/combined/*', middlewareA);
+  app.get(
+    '/test-main-inline/combined/resource',
+    async function combinedInlineMw(_c, next) {
+      await next();
+    },
+    c => c.text('combined response'),
+  );
+
   // Route patterns: HTTP methods, .all(), .on(), sync/async, errors
   app.route('/test-routes', routePatterns);
 

dev-packages/e2e-tests/test-applications/hono-4/tests/errors.test.ts

@@ -32,6 +32,7 @@ test.describe('route handler errors', () => {
     expect(errorEvent.transaction).toBe('GET /error/:cause');
     expect(errorEvent.request?.method).toBe('GET');
     expect(errorEvent.request?.url).toContain('/error/test-cause');
+    expect(errorEvent.request?.headers).toBeDefined();
 
     expect(errorEvent.contexts?.trace?.trace_id).toBe(transactionEvent.contexts?.trace?.trace_id);
   });
@@ -217,7 +218,9 @@ test.describe('nested sub-app errors', () => {
       handled: false,
       type: 'auto.http.hono.context_error',
     });
+    expect(errorEvent.request?.method).toBe('GET');
     expect(errorEvent.request?.url).toContain('/test-errors/nested/child/error');
+    expect(errorEvent.request?.headers).toBeDefined();
   });
 });
 

dev-packages/e2e-tests/test-applications/hono-4/tests/middleware.test.ts

@@ -248,3 +248,70 @@ test.describe('inline middleware spans (sub-app)', () => {
     }
   }
 });
+
+const MAIN_INLINE_PREFIX = '/test-main-inline';
+
+const MAIN_INLINE_CASES = [
+  { name: '.get()', path: '/get', method: 'GET', expectedMiddlewareName: 'mainInlineGet' },
+  { name: '.post()', path: '/post', method: 'POST', expectedMiddlewareName: 'mainInlinePost' },
+  { name: '.all()', path: '/all', method: 'GET', expectedMiddlewareName: 'mainInlineAll' },
+] as const;
+
+test.describe('inline middleware spans (main app)', () => {
+  MAIN_INLINE_CASES.forEach(({ name, path, method, expectedMiddlewareName }) => {
+    test(`creates middleware span for inline middleware via ${name}`, async ({ baseURL }) => {
+      const fullPath = `${MAIN_INLINE_PREFIX}${path}`;
+
+      const transactionPromise = waitForTransaction(APP_NAME, event => {
+        return event.contexts?.trace?.op === 'http.server' && event.transaction === `${method} ${fullPath}`;
+      });
+
+      const response = await fetch(`${baseURL}${fullPath}`, { method });
+      expect(response.status).toBe(200);
+
+      const transaction = await transactionPromise;
+      expect(transaction.transaction).toBe(`${method} ${fullPath}`);
+
+      const spans = transaction.spans || [];
+      const inlineSpan = spans.find(s => s.description === expectedMiddlewareName);
+
+      expect(inlineSpan).toBeDefined();
+      expect(inlineSpan?.op).toBe('middleware.hono');
+      expect(inlineSpan?.origin).toBe('auto.middleware.hono');
+      expect(inlineSpan?.status).not.toBe('internal_error');
+
+      const middlewareSpans = spans.filter(s => s.op === 'middleware.hono');
+      expect(middlewareSpans).toHaveLength(1);
+    });
+  });
+
+  test('creates spans for both .use() middleware and inline middleware via .get()', async ({ baseURL }) => {
+    const fullPath = `${MAIN_INLINE_PREFIX}/combined/resource`;
+
+    const transactionPromise = waitForTransaction(APP_NAME, event => {
+      return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${fullPath}`;
+    });
+
+    const response = await fetch(`${baseURL}${fullPath}`);
+    expect(response.status).toBe(200);
+
+    const transaction = await transactionPromise;
+    expect(transaction.transaction).toBe(`GET ${fullPath}`);
+
+    const spans = transaction.spans || [];
+    const middlewareSpans = spans.filter(s => s.op === 'middleware.hono');
+
+    expect(middlewareSpans).toHaveLength(2);
+
+    const [spanA, spanB] = middlewareSpans.sort((a, b) => (a.description ?? '').localeCompare(b.description ?? ''));
+    expect(spanA?.description).toBe('combinedInlineMw');
+    expect(spanA?.op).toBe('middleware.hono');
+    expect(spanA?.origin).toBe('auto.middleware.hono');
+    expect(spanA?.status).not.toBe('internal_error');
+
+    expect(spanB?.description).toBe('middlewareA');
+    expect(spanB?.op).toBe('middleware.hono');
+    expect(spanB?.origin).toBe('auto.middleware.hono');
+    expect(spanB?.status).not.toBe('internal_error');
+  });
+});

dev-packages/e2e-tests/test-applications/hono-4/tests/route-patterns.test.ts

@@ -11,10 +11,10 @@ const REGISTRATION_STYLES = [
 ] as const;
 
 test.describe('HTTP methods', () => {
-  ['POST', 'PUT', 'DELETE', 'PATCH'].forEach(method => {
+  ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].forEach(method => {
     test(`sends transaction for ${method}`, async ({ baseURL }) => {
       const transactionPromise = waitForTransaction(APP_NAME, event => {
-        return event.contexts?.trace?.op === 'http.server' && !!event.transaction?.includes(PREFIX);
+        return event.contexts?.trace?.op === 'http.server' && event.transaction === `${method} ${PREFIX}`;
       });
 
       const response = await fetch(`${baseURL}${PREFIX}`, { method });
@@ -23,15 +23,20 @@ test.describe('HTTP methods', () => {
       const transaction = await transactionPromise;
       expect(transaction.transaction).toBe(`${method} ${PREFIX}`);
       expect(transaction.contexts?.trace?.op).toBe('http.server');
+      expect(transaction.contexts?.trace?.data?.['sentry.source']).toBe('route');
+
+      const spans = transaction.spans || [];
+      const middlewareSpans = spans.filter(s => s.op === 'middleware.hono');
+      expect(middlewareSpans).toEqual([]);
     });
   });
 });
 
 test.describe('route registration styles', () => {
   REGISTRATION_STYLES.forEach(({ name, path }) => {
-    test(`${name} sends transaction`, async ({ baseURL }) => {
+    test(`${name} sends transaction with route source`, async ({ baseURL }) => {
       const transactionPromise = waitForTransaction(APP_NAME, event => {
-        return event.contexts?.trace?.op === 'http.server' && !!event.transaction?.includes(`${PREFIX}${path}`);
+        return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${PREFIX}${path}`;
       });
 
       const response = await fetch(`${baseURL}${PREFIX}${path}`);
@@ -40,6 +45,11 @@ test.describe('route registration styles', () => {
       const transaction = await transactionPromise;
       expect(transaction.transaction).toBe(`GET ${PREFIX}${path}`);
       expect(transaction.contexts?.trace?.op).toBe('http.server');
+      expect(transaction.contexts?.trace?.data?.['sentry.source']).toBe('route');
+
+      const spans = transaction.spans || [];
+      const middlewareSpans = spans.filter(s => s.op === 'middleware.hono');
+      expect(middlewareSpans).toEqual([]);
     });
   });
 
@@ -49,21 +59,74 @@ test.describe('route registration styles', () => {
   ].forEach(({ name, path }) => {
     test(`${name} responds to POST`, async ({ baseURL }) => {
       const transactionPromise = waitForTransaction(APP_NAME, event => {
-        return event.contexts?.trace?.op === 'http.server' && !!event.transaction?.includes(`${PREFIX}${path}`);
+        return event.contexts?.trace?.op === 'http.server' && event.transaction === `POST ${PREFIX}${path}`;
       });
 
       const response = await fetch(`${baseURL}${PREFIX}${path}`, { method: 'POST' });
       expect(response.status).toBe(200);
 
       const transaction = await transactionPromise;
       expect(transaction.transaction).toBe(`POST ${PREFIX}${path}`);
+      expect(transaction.contexts?.trace?.data?.['sentry.source']).toBe('route');
+
+      const spans = transaction.spans || [];
+      const middlewareSpans = spans.filter(s => s.op === 'middleware.hono');
+      expect(middlewareSpans).toEqual([]);
+    });
+  });
+});
+
+test.describe('request data extraction', () => {
+  test('includes method, url, and headers on transaction', async ({ baseURL }) => {
+    const transactionPromise = waitForTransaction(APP_NAME, event => {
+      return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${PREFIX}`;
+    });
+
+    const response = await fetch(`${baseURL}${PREFIX}`);
+    expect(response.status).toBe(200);
+
+    const transaction = await transactionPromise;
+    expect(transaction.request?.method).toBe('GET');
+    expect(transaction.request?.url).toContain(PREFIX);
+    expect(transaction.request?.headers).toBeDefined();
+  });
+
+  test('includes query_string when present', async ({ baseURL }) => {
+    const transactionPromise = waitForTransaction(APP_NAME, event => {
+      return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${PREFIX}`;
     });
+
+    const response = await fetch(`${baseURL}${PREFIX}?foo=bar&baz=42`);
+    expect(response.status).toBe(200);
+
+    const transaction = await transactionPromise;
+
+    expect(transaction.request?.method).toBe('GET');
+    expect(transaction.request?.url).toContain(PREFIX);
+    expect(transaction.request?.query_string).toBe('foo=bar&baz=42');
+  });
+
+  test('includes request data for POST with headers', async ({ baseURL }) => {
+    const transactionPromise = waitForTransaction(APP_NAME, event => {
+      return event.contexts?.trace?.op === 'http.server' && event.transaction === `POST ${PREFIX}`;
+    });
+
+    const response = await fetch(`${baseURL}${PREFIX}`, {
+      method: 'POST',
+      headers: { 'X-Custom-Header': 'test-value' },
+    });
+    expect(response.status).toBe(200);
+
+    const transaction = await transactionPromise;
+    expect(transaction.request?.method).toBe('POST');
+    expect(transaction.request?.url).toContain(PREFIX);
+    expect(transaction.request?.headers?.['x-custom-header']).toBe('test-value');
   });
 });
 
 test('async handler sends transaction', async ({ baseURL }) => {
   const transactionPromise = waitForTransaction(APP_NAME, event => {
-    return event.contexts?.trace?.op === 'http.server' && !!event.transaction?.includes(`${PREFIX}/async`);
+    return event.contexts?.trace?.op === 'http.server' && event.transaction === `GET ${PREFIX}/async`;
   });
 
   const response = await fetch(`${baseURL}${PREFIX}/async`);
@@ -72,4 +135,9 @@ test('async handler sends transaction', async ({ baseURL }) => {
   const transaction = await transactionPromise;
   expect(transaction.transaction).toBe(`GET ${PREFIX}/async`);
   expect(transaction.contexts?.trace?.op).toBe('http.server');
+  expect(transaction.contexts?.trace?.data?.['sentry.source']).toBe('route');
+
+  const spans = transaction.spans || [];
+  const middlewareSpans = spans.filter(s => s.op === 'middleware.hono');
+  expect(middlewareSpans).toEqual([]);
 });

packages/hono/src/shared/applyPatches.ts

@@ -2,7 +2,7 @@ import { debug } from '@sentry/core';
 import type { Env, Hono } from 'hono';
 import { DEBUG_BUILD } from '../debug-build';
 import { patchAppRequest } from './patchAppRequest';
-import { patchAppUse } from './patchAppUse';
+import { patchAppUse, patchHttpMethodHandlers } from './patchAppUse';
 import { type HonoRoute, type RouteHookHandle, installRouteHookOnPrototype, wrapSubAppMiddleware } from './patchRoute';
 
 // Lazily set by the first call to earlyPatchHono or applyPatches.
@@ -31,6 +31,9 @@ export function applyPatches<E extends Env>(app: Hono<E>): void {
   // `app.use` (instance own property) — wraps middleware at registration time on this instance.
   patchAppUse(app);
 
+  // `app.get`, `app.post`, … (instance own properties) — wraps inline middleware (all-but-last handler).
+  patchHttpMethodHandlers(app);
+
   patchAppRequest(app);
 
   _routeHook.activate();

packages/hono/src/shared/patchAppUse.ts

@@ -4,7 +4,11 @@ import { DEBUG_BUILD } from '../debug-build';
 import { wrapMiddlewareWithSpan } from './wrapMiddlewareSpan';
 
 // oxlint-disable-next-line typescript/no-explicit-any
-const patchedInstances = new WeakSet<Hono<any>>();
+const patchedUseInstances = new WeakSet<Hono<any>>();
+// oxlint-disable-next-line typescript/no-explicit-any
+const patchedMethodInstances = new WeakSet<Hono<any>>();
+
+const HTTP_METHODS = ['get', 'post', 'put', 'delete', 'options', 'patch', 'all'] as const;
 
 /**
  * Patches `app.use` (instance own property) on a Hono instance to instrument middleware at registration time.
@@ -13,12 +17,12 @@ const patchedInstances = new WeakSet<Hono<any>>();
  * Idempotent.
  */
 export function patchAppUse<E extends Env>(app: Hono<E>): void {
-  if (patchedInstances.has(app)) {
+  if (patchedUseInstances.has(app)) {
     DEBUG_BUILD && debug.log('[hono] app.use already patched — skipping.');
     return;
   }
 
-  patchedInstances.add(app);
+  patchedUseInstances.add(app);
 
   app.use = new Proxy(app.use, {
     apply(target: typeof app.use, thisArg: typeof app, args: Parameters<typeof app.use>): ReturnType<typeof app.use> {
@@ -34,3 +38,54 @@ export function patchAppUse<E extends Env>(app: Hono<E>): void {
     },
   });
 }
+
+/**
+ * Patches HTTP method class fields (get, post, put, delete, options, patch, all) to instrument inline middleware at registration time.
+ *
+ * For `app.get('/path', mw1, mw2, handler)`, all handlers except the last are middleware and get wrapped with spans.
+ * The final handler (the route handler) is already covered by the root http.server transaction.
+ */
+export function patchHttpMethodHandlers<E extends Env>(app: Hono<E>): void {
+  if (patchedMethodInstances.has(app)) {
+    DEBUG_BUILD && debug.log('[hono] HTTP method handlers already patched - skipping.');
+    return;
+  }
+
+  patchedMethodInstances.add(app);
+
+  for (const method of HTTP_METHODS) {
+    app[method] = new Proxy(app[method], {
+      apply(target, thisArg, args: unknown[]) {
+        return Reflect.apply(target, thisArg, wrapInlineMiddleware(args));
+      },
+    });
+  }
+
+  app.on = new Proxy(app.on, {
+    apply(target, thisArg, args: unknown[]) {
+      // .on(method, path, ...handlers) — first two args are method and path
+      const [method, path, ...handlers] = args;
+      return Reflect.apply(target, thisArg, [method, path, ...wrapInlineMiddleware(handlers)]);
+    },
+  });
+}
+
+/**
+ * Given `[path?, ...handlers]` or `[...handlers]`, wraps all handlers except the last one with spans.
+ * The last handler is the route handler and is left as-is.
+ */
+function wrapInlineMiddleware(args: unknown[]): unknown[] {
+  const hasPathPrefix = typeof args[0] === 'string';
+  const handlersStart = hasPathPrefix ? 1 : 0;
+  const handlers = args.slice(handlersStart) as MiddlewareHandler[];
+
+  if (handlers.length <= 1) {
+    return args;
+  }
+
+  const wrapped = [...args];
+  for (let i = handlersStart; i < wrapped.length - 1; i++) {
+    wrapped[i] = wrapMiddlewareWithSpan(wrapped[i] as MiddlewareHandler);
+  }
+  return wrapped;
+}