refactor: replace wrapFindRouteWithTracing with wrapHandlerWithTracing

Export a simpler `wrapHandlerWithTracing` that wraps a single EventHandler
at init/codegen time instead of wrapping the entire ~findRoute function at
runtime. This eliminates per-request overhead — tracing is applied once
during build, not on every route lookup.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: logaretm

src/tracing.ts

@@ -1,11 +1,6 @@
 import type { H3Event } from "./event.ts";
 import type { H3, H3Core } from "./h3.ts";
-import {
-  type H3Plugin,
-  type H3Route,
-  type MatchedRoute,
-  type MiddlewareOptions,
-} from "./types/h3.ts";
+import { type H3Plugin, type H3Route, type MiddlewareOptions } from "./types/h3.ts";
 import type { EventHandler, Middleware } from "./types/handler.ts";
 
 /**
@@ -148,67 +143,30 @@ export function tracingPlugin(traceOpts?: TracingPluginOptions): H3Plugin {
   };
 }
 
-type FindRouteFunction = (event: H3Event) => MatchedRoute<H3Route> | void;
-
 /**
- * Wraps a `~findRoute` function so that returned route handlers and middleware
- * are traced via the `h3.request` diagnostics channel. Intended for frameworks
- * (e.g. nitro) that resolve routes at request time without pushing them into
- * `h3["~routes"]`.
+ * Wraps an event handler so its execution is traced via the `h3.request`
+ * diagnostics channel with `type: "route"`. Intended to be called once per
+ * handler at initialization time (e.g. during codegen or module load), not
+ * per request.
  *
- * Returns the original function unchanged when `diagnostics_channel` is not
- * available.
+ * Returns the handler unchanged when `diagnostics_channel` is unavailable
+ * or the handler is already traced.
  */
-export function wrapFindRouteWithTracing(
-  findRoute: FindRouteFunction,
-  traceOpts?: TracingPluginOptions,
-): FindRouteFunction {
+export function wrapHandlerWithTracing(handler: EventHandler): EventHandler {
   const { tracingChannel } = globalThis.process?.getBuiltinModule?.("diagnostics_channel") ?? {};
-
   if (!tracingChannel) {
-    return findRoute;
-  }
-
-  const channel = tracingChannel("h3.request");
-
-  function wrapHandler(handler: MaybeTracedEventHandler): EventHandler {
-    if (handler.__traced__ || traceOpts?.traceRoutes === false) {
-      return handler;
-    }
-    const wrapped: MaybeTracedEventHandler = (...args) => {
-      return channel.tracePromise(async () => handler(...args), {
-        event: args[0],
-        type: "route",
-      } satisfies TracingRequestEvent);
-    };
-    wrapped.__traced__ = true;
-    return wrapped;
+    return handler;
   }
-
-  function wrapMiddleware(middleware: MaybeTracedMiddleware): Middleware {
-    if (middleware.__traced__ || traceOpts?.traceMiddleware === false) {
-      return middleware;
-    }
-    const wrapped: MaybeTracedMiddleware = (...args) => {
-      return channel.tracePromise(async () => middleware(...args), {
-        event: args[0],
-        type: "middleware",
-      } satisfies TracingRequestEvent);
-    };
-    wrapped.__traced__ = true;
-    return wrapped;
+  if ((handler as MaybeTracedEventHandler).__traced__) {
+    return handler;
   }
-
-  return (event: H3Event) => {
-    const route = findRoute(event);
-    if (route?.data.handler) {
-      route.data.handler = wrapHandler(route.data.handler);
-    }
-    if (route?.data.middleware) {
-      for (let i = 0; i < route.data.middleware.length; i++) {
-        route.data.middleware[i] = wrapMiddleware(route.data.middleware[i]);
-      }
-    }
-    return route;
+  const channel = tracingChannel("h3.request");
+  const wrapped: MaybeTracedEventHandler = (...args) => {
+    return channel.tracePromise(async () => handler(...args), {
+      event: args[0],
+      type: "route",
+    } satisfies TracingRequestEvent);
   };
+  wrapped.__traced__ = true;
+  return wrapped;
 }

test/tracing.test.ts

@@ -1158,125 +1158,73 @@ describe("tracing channels for H3Core instances", () => {
   });
 });
 
-describe("wrapFindRouteWithTracing", () => {
-  it("wraps route handlers returned by findRoute", async () => {
+describe("wrapHandlerWithTracing", () => {
+  it("wraps a handler so route traces are emitted", async () => {
     const listener = createTracingListener();
     const { H3Core } = await import("../src/h3.ts");
-    const { wrapFindRouteWithTracing } = await import("../src/tracing.ts");
+    const { wrapHandlerWithTracing } = await import("../src/tracing.ts");
     const { H3Event } = await import("../src/event.ts");
 
     try {
       const app = new H3Core();
-      const routeHandler = () => "file-based response";
+      const routeHandler = wrapHandlerWithTracing(() => "traced response");
 
-      const baseFindRoute = (event: any) => {
-        if (event.url.pathname === "/file-route" && event.req.method === "GET") {
-          return {
-            data: { method: "GET", route: "/file-route", handler: routeHandler },
-            params: {},
-          };
+      app["~findRoute"] = (event: any) => {
+        if (event.url.pathname === "/test" && event.req.method === "GET") {
+          return { data: { method: "GET", route: "/test", handler: routeHandler }, params: {} };
         }
         return undefined;
       };
 
-      app["~findRoute"] = wrapFindRouteWithTracing(baseFindRoute as any);
-
-      const request = new Request("http://localhost/file-route", { method: "GET" });
+      const request = new Request("http://localhost/test", { method: "GET" });
       const event = new H3Event(request, undefined, app as any);
 
       await app.handler(event);
       await new Promise((resolve) => setTimeout(resolve, 10));
 
       const routeEvents = listener.events.filter((e) => e.asyncStart?.data.type === "route");
-      expect(routeEvents.some((e) => e.asyncStart?.data.event.url.pathname === "/file-route")).toBe(
-        true,
-      );
+      expect(routeEvents.some((e) => e.asyncStart?.data.event.url.pathname === "/test")).toBe(true);
     } finally {
       listener.cleanup();
     }
   });
 
-  it("does not double-wrap handlers across repeated calls", async () => {
-    const listener = createTracingListener();
-    const { H3Core } = await import("../src/h3.ts");
-    const { wrapFindRouteWithTracing } = await import("../src/tracing.ts");
-    const { H3Event } = await import("../src/event.ts");
-
-    try {
-      const app = new H3Core();
-      const routeHandler = () => "ok";
-
-      const cachedRoute = {
-        data: { method: "GET" as const, route: "/cached", handler: routeHandler },
-        params: {},
-      };
-
-      app["~findRoute"] = wrapFindRouteWithTracing((() => cachedRoute) as any);
-
-      const run = async () => {
-        const request = new Request("http://localhost/cached", { method: "GET" });
-        const event = new H3Event(request, undefined, app as any);
-        await app.handler(event);
-      };
-
-      await run();
-      const wrappedHandler = cachedRoute.data.handler;
-      expect((wrappedHandler as any).__traced__).toBe(true);
-
-      await run();
-      await run();
+  it("is idempotent — wrapping twice returns the same wrapper", async () => {
+    const { wrapHandlerWithTracing } = await import("../src/tracing.ts");
 
-      expect(cachedRoute.data.handler).toBe(wrappedHandler);
+    const handler = () => "ok";
+    const wrapped = wrapHandlerWithTracing(handler);
+    const doubleWrapped = wrapHandlerWithTracing(wrapped);
 
-      await new Promise((resolve) => setTimeout(resolve, 10));
-
-      const routeAsyncStarts = listener.events.filter((e) => e.asyncStart?.data.type === "route");
-      expect(routeAsyncStarts.length).toBe(3);
-    } finally {
-      listener.cleanup();
-    }
+    expect(doubleWrapped).toBe(wrapped);
+    expect((wrapped as any).__traced__).toBe(true);
   });
 
-  it("mutates cached route.data.middleware in place without reallocating", async () => {
+  it("emits exactly one trace per request on a pre-wrapped handler", async () => {
     const listener = createTracingListener();
     const { H3Core } = await import("../src/h3.ts");
-    const { wrapFindRouteWithTracing } = await import("../src/tracing.ts");
+    const { wrapHandlerWithTracing } = await import("../src/tracing.ts");
     const { H3Event } = await import("../src/event.ts");
 
     try {
       const app = new H3Core();
-      const mw = (event: any) => {
-        event.context.mw = true;
-      };
-      const cachedRoute = {
-        data: {
-          method: "GET" as const,
-          route: "/cached",
-          handler: () => "ok",
-          middleware: [mw],
-        },
-        params: {},
-      };
+      const routeHandler = wrapHandlerWithTracing(() => "ok");
 
-      app["~findRoute"] = wrapFindRouteWithTracing((() => cachedRoute) as any);
+      app["~findRoute"] = () => ({
+        data: { method: "GET" as const, route: "/test", handler: routeHandler },
+        params: {},
+      });
 
       const run = async () => {
-        const request = new Request("http://localhost/cached", { method: "GET" });
+        const request = new Request("http://localhost/test", { method: "GET" });
         const event = new H3Event(request, undefined, app as any);
         await app.handler(event);
       };
 
       await run();
-      const middlewareArray = cachedRoute.data.middleware;
-      const wrappedMw = middlewareArray[0];
-      expect((wrappedMw as any).__traced__).toBe(true);
-
       await run();
       await run();
 
-      expect(cachedRoute.data.middleware).toBe(middlewareArray);
-      expect(cachedRoute.data.middleware[0]).toBe(wrappedMw);
-
       await new Promise((resolve) => setTimeout(resolve, 10));
 
       const routeAsyncStarts = listener.events.filter((e) => e.asyncStart?.data.type === "route");