trickle-observe 0.2.128 → 0.2.130

package/dist/register.d.ts

@@ -9,8 +9,8 @@
  *
  *   TRICKLE_BACKEND_URL=http://localhost:4888 node -r trickle/register app.js
  *
- * This module patches Node's module loader to intercept `require('express')`
- * and automatically instrument any Express app created — no code changes needed.
+ * This module patches Node's module loader to intercept framework requires
+ * (Express, Fastify, Koa, Hono) and automatically instrument any app created.
  *
  * Supported environment variables:
  *   TRICKLE_BACKEND_URL  — Backend URL (default: http://localhost:4888)

package/dist/register.js

@@ -10,8 +10,8 @@
  *
  *   TRICKLE_BACKEND_URL=http://localhost:4888 node -r trickle/register app.js
  *
- * This module patches Node's module loader to intercept `require('express')`
- * and automatically instrument any Express app created — no code changes needed.
+ * This module patches Node's module loader to intercept framework requires
+ * (Express, Fastify, Koa, Hono) and automatically instrument any app created.
  *
  * Supported environment variables:
  *   TRICKLE_BACKEND_URL  — Backend URL (default: http://localhost:4888)
@@ -26,6 +26,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const module_1 = __importDefault(require("module"));
 const transport_1 = require("./transport");
 const express_1 = require("./express");
+const fastify_1 = require("./fastify");
+const koa_1 = require("./koa");
+const hono_1 = require("./hono");
 const env_detect_1 = require("./env-detect");
 const M = module_1.default;
 const originalLoad = M._load;
@@ -35,6 +38,7 @@ const backendUrl = process.env.TRICKLE_BACKEND_URL || 'http://localhost:4888';
 const enabled = process.env.TRICKLE_ENABLED !== '0' && process.env.TRICKLE_ENABLED !== 'false';
 const debug = process.env.TRICKLE_DEBUG === '1' || process.env.TRICKLE_DEBUG === 'true';
 const envOverride = process.env.TRICKLE_ENV || undefined;
+const environment = envOverride || (0, env_detect_1.detectEnvironment)();
 if (enabled) {
     // Configure the transport
     (0, transport_1.configure)({
@@ -42,7 +46,7 @@ if (enabled) {
         batchIntervalMs: 2000,
         debug,
         enabled: true,
-        environment: envOverride || (0, env_detect_1.detectEnvironment)(),
+        environment,
     });
     if (debug) {
         console.log(`[trickle] Auto-instrumentation enabled (backend: ${backendUrl})`);
@@ -55,6 +59,21 @@ if (enabled) {
             patched.add('express');
             return patchExpress(exports, request, parent);
         }
+        // Intercept require('fastify')
+        if (request === 'fastify' && !patched.has('fastify')) {
+            patched.add('fastify');
+            return patchFastify(exports, request, parent);
+        }
+        // Intercept require('koa')
+        if (request === 'koa' && !patched.has('koa')) {
+            patched.add('koa');
+            return patchKoa(exports, request, parent);
+        }
+        // Intercept require('hono')
+        if (request === 'hono' && !patched.has('hono')) {
+            patched.add('hono');
+            return patchHono(exports, request, parent);
+        }
         return exports;
     };
 }
@@ -63,15 +82,12 @@ else if (debug) {
 }
 /**
  * Wrap the Express factory function so every app created is auto-instrumented.
- * Preserves all static properties (express.json, express.static, etc.).
  */
 function patchExpress(originalExpress, request, parent) {
     function wrappedExpress(...args) {
         const app = originalExpress.apply(this, args);
         try {
-            (0, express_1.instrumentExpress)(app, {
-                environment: envOverride || (0, env_detect_1.detectEnvironment)(),
-            });
+            (0, express_1.instrumentExpress)(app, { environment });
             if (debug) {
                 console.log('[trickle] Auto-instrumented Express app');
             }
@@ -84,22 +100,126 @@ function patchExpress(originalExpress, request, parent) {
         }
         return app;
     }
-    // Copy all static properties (express.json, express.static, express.Router, etc.)
     for (const key of Object.keys(originalExpress)) {
         wrappedExpress[key] = originalExpress[key];
     }
-    // Preserve prototype chain
     Object.setPrototypeOf(wrappedExpress, Object.getPrototypeOf(originalExpress));
-    // Update require cache so subsequent require('express') returns the patched version
     try {
         const resolvedPath = M._resolveFilename(request, parent);
         if (require.cache[resolvedPath]) {
             require.cache[resolvedPath].exports = wrappedExpress;
         }
     }
-    catch {
-        // Cache update failed — first require still returns patched, but subsequent
-        // requires from other modules may get the original. This is rare.
-    }
+    catch { }
     return wrappedExpress;
 }
+/**
+ * Wrap the Fastify factory function.
+ */
+function patchFastify(origExports, request, parent) {
+    const factory = typeof origExports === 'function' ? origExports : origExports.default || origExports.fastify;
+    if (typeof factory !== 'function')
+        return origExports;
+    const wrappedFactory = function (...args) {
+        const app = factory.apply(this, args);
+        try {
+            (0, fastify_1.instrumentFastify)(app, { environment });
+            if (debug)
+                console.log('[trickle] Auto-instrumented Fastify app');
+        }
+        catch (err) {
+            if (debug)
+                console.warn(`[trickle] Failed to auto-instrument Fastify: ${err.message}`);
+        }
+        return app;
+    };
+    for (const key of Object.keys(factory)) {
+        wrappedFactory[key] = factory[key];
+    }
+    if (typeof origExports === 'function') {
+        try {
+            const resolvedPath = M._resolveFilename(request, parent);
+            if (require.cache[resolvedPath])
+                require.cache[resolvedPath].exports = wrappedFactory;
+        }
+        catch { }
+        return wrappedFactory;
+    }
+    const wrapped = { ...origExports };
+    if (origExports.default)
+        wrapped.default = wrappedFactory;
+    if (origExports.fastify)
+        wrapped.fastify = wrappedFactory;
+    return wrapped;
+}
+/**
+ * Wrap the Koa constructor.
+ */
+function patchKoa(origExports, request, parent) {
+    const KoaClass = typeof origExports === 'function' ? origExports : origExports.default;
+    if (typeof KoaClass !== 'function')
+        return origExports;
+    const WrappedKoa = function (...args) {
+        const app = new KoaClass(...args);
+        try {
+            (0, koa_1.instrumentKoa)(app, { environment });
+            if (debug)
+                console.log('[trickle] Auto-instrumented Koa app');
+        }
+        catch (err) {
+            if (debug)
+                console.warn(`[trickle] Failed to auto-instrument Koa: ${err.message}`);
+        }
+        return app;
+    };
+    WrappedKoa.prototype = KoaClass.prototype;
+    for (const key of Object.keys(KoaClass)) {
+        WrappedKoa[key] = KoaClass[key];
+    }
+    if (typeof origExports === 'function') {
+        try {
+            const resolvedPath = M._resolveFilename(request, parent);
+            if (require.cache[resolvedPath])
+                require.cache[resolvedPath].exports = WrappedKoa;
+        }
+        catch { }
+        return WrappedKoa;
+    }
+    return { ...origExports, default: WrappedKoa };
+}
+/**
+ * Wrap the Hono constructor.
+ */
+function patchHono(origExports, request, parent) {
+    const HonoClass = origExports.Hono || (origExports.default && origExports.default.Hono);
+    if (typeof HonoClass !== 'function')
+        return origExports;
+    const WrappedHono = function (...args) {
+        const app = new HonoClass(...args);
+        try {
+            (0, hono_1.instrumentHono)(app, { environment });
+            if (debug)
+                console.log('[trickle] Auto-instrumented Hono app');
+        }
+        catch (err) {
+            if (debug)
+                console.warn(`[trickle] Failed to auto-instrument Hono: ${err.message}`);
+        }
+        return app;
+    };
+    WrappedHono.prototype = HonoClass.prototype;
+    for (const key of Object.keys(HonoClass)) {
+        WrappedHono[key] = HonoClass[key];
+    }
+    const result = { ...origExports, Hono: WrappedHono };
+    try {
+        const resolvedPath = M._resolveFilename(request, parent);
+        if (require.cache[resolvedPath]) {
+            const cached = require.cache[resolvedPath].exports;
+            if (cached.Hono)
+                cached.Hono = WrappedHono;
+        }
+    }
+    catch { }
+    return result;
+}

package/observe-esm-hooks.mjs

@@ -648,24 +648,106 @@ function transformSource(source, url, originalSource) {
     }
   }
 
-  // If nothing to wrap or trace, return original
-  if (exportedFunctions.length === 0 && exportedDefaults.length === 0 && namedExports.length === 0 && !hasVarTracing) {
+  // ── Detect framework imports and inject instrumentation ──
+  // Scan for: import express from 'express' / import { Hono } from 'hono' etc.
+  const frameworkInjects = [];
+  const expressImportMatch = source.match(/import\s+(\w+)\s+from\s+['"]express['"]/);
+  const fastifyImportMatch = source.match(/import\s+(\w+)\s+from\s+['"]fastify['"]/);
+  const koaImportMatch = source.match(/import\s+(\w+)\s+from\s+['"]koa['"]/);
+  const honoImportMatch = source.match(/import\s+\{\s*Hono\s*\}\s+from\s+['"]hono['"]/);
+
+  if (expressImportMatch) {
+    // Express: imported as factory. Detect `const app = express()` and inject instrument(app)
+    const factoryName = expressImportMatch[1];
+    const appMatch = source.match(new RegExp(`(?:const|let|var)\\s+(\\w+)\\s*=\\s*${factoryName}\\s*\\(`));
+    if (appMatch) {
+      frameworkInjects.push({ framework: 'express', appVar: appMatch[1], importPath: config.wrapperPath.replace('/wrap.js', '/express.js') });
+    }
+  }
+  if (fastifyImportMatch) {
+    const factoryName = fastifyImportMatch[1];
+    const appMatch = source.match(new RegExp(`(?:const|let|var)\\s+(\\w+)\\s*=\\s*${factoryName}\\s*\\(`));
+    if (appMatch) {
+      frameworkInjects.push({ framework: 'fastify', appVar: appMatch[1], importPath: config.wrapperPath.replace('/wrap.js', '/fastify.js') });
+    }
+  }
+  if (koaImportMatch) {
+    const className = koaImportMatch[1];
+    const appMatch = source.match(new RegExp(`(?:const|let|var)\\s+(\\w+)\\s*=\\s*new\\s+${className}\\s*\\(`));
+    if (appMatch) {
+      frameworkInjects.push({ framework: 'koa', appVar: appMatch[1], importPath: config.wrapperPath.replace('/wrap.js', '/koa.js') });
+    }
+  }
+  if (honoImportMatch) {
+    const appMatch = source.match(/(?:const|let|var)\s+(\w+)\s*=\s*new\s+Hono\s*\(/);
+    if (appMatch) {
+      frameworkInjects.push({ framework: 'hono', appVar: appMatch[1], importPath: config.wrapperPath.replace('/wrap.js', '/hono.js') });
+    }
+  }
+
+  // If nothing to wrap or trace, but we have framework injections, continue
+  if (exportedFunctions.length === 0 && exportedDefaults.length === 0 && namedExports.length === 0 && !hasVarTracing && frameworkInjects.length === 0) {
     return source;
   }
 
+  // If ONLY framework injections (no function wrapping needed), inject directly
+  if (exportedFunctions.length === 0 && exportedDefaults.length === 0 && namedExports.length === 0 && !hasVarTracing && frameworkInjects.length > 0) {
+    const lines = source.split('\n');
+    const injections = [];
+    for (const fi of frameworkInjects) {
+      const instrumentFn = fi.framework === 'express' ? 'instrumentExpress'
+        : fi.framework === 'fastify' ? 'instrumentFastify'
+        : fi.framework === 'koa' ? 'instrumentKoa'
+        : 'instrumentHono';
+      const fiPath = fi.importPath.replace(/\\/g, '\\\\');
+      injections.push(`import { createRequire as __cr_fw } from 'node:module';`);
+      injections.push(`const __req_fw = __cr_fw(import.meta.url);`);
+      injections.push(`try { const __fwMod = __req_fw('${fiPath}'); __fwMod.${instrumentFn}(${fi.appVar}, { environment: process.env.TRICKLE_ENV || 'development' }); } catch(__e) { if (${config.debug}) console.error('[trickle/esm] Framework instrumentation failed:', __e.message); }`);
+    }
+    // Find the line after the app creation and insert
+    for (const fi of frameworkInjects) {
+      const appPattern = new RegExp(`(?:const|let|var)\\s+${fi.appVar}\\s*=`);
+      for (let i = 0; i < lines.length; i++) {
+        if (appPattern.test(lines[i])) {
+          // Find end of statement
+          let endLine = i;
+          let depth = 0;
+          for (let j = i; j < lines.length; j++) {
+            for (const ch of lines[j]) {
+              if (ch === '(' || ch === '{' || ch === '[') depth++;
+              if (ch === ')' || ch === '}' || ch === ']') depth--;
+            }
+            if (lines[j].includes(';') && depth <= 0) { endLine = j; break; }
+            if (j > i && depth <= 0) { endLine = j - 1; break; }
+          }
+          lines.splice(endLine + 1, 0, ...injections);
+          break;
+        }
+      }
+    }
+    if (config.debug) {
+      console.log(`[trickle/esm] Injected ${frameworkInjects.map(f => f.framework).join(', ')} instrumentation into ${moduleName}`);
+    }
+    return lines.join('\n');
+  }
+
   // Add wrapper import and wrapping code
   const wrapperPathEscaped = config.wrapperPath.replace(/\\/g, '\\\\');
 
   // Insert wrapper setup at the top (after imports, before user code)
   // Using import + createRequire to load CJS wrapper from ESM context
+  // Always create __require if we have exports OR framework injections
+  const needsWrapper = exportedFunctions.length > 0 || exportedDefaults.length > 0 || namedExports.length > 0 || frameworkInjects.length > 0;
   const wrapSetup = [
     '',
     '// [trickle] Auto-observation wrappers',
     `import { createRequire as __cr } from 'node:module';`,
     `const __require = __cr(import.meta.url);`,
-    `const { wrapFunction: __tw } = __require('${wrapperPathEscaped}');`,
-    `const __twOpts = (name, paramNames) => { const o = { functionName: name, module: '${moduleName}', trackArgs: true, trackReturn: true, sampleRate: 1, maxDepth: 5, environment: process.env.TRICKLE_ENV || 'development', enabled: true }; if (paramNames && paramNames.length) o.paramNames = paramNames; return o; };`,
   ];
+  if (exportedFunctions.length > 0 || exportedDefaults.length > 0 || namedExports.length > 0) {
+    wrapSetup.push(`const { wrapFunction: __tw } = __require('${wrapperPathEscaped}');`);
+    wrapSetup.push(`const __twOpts = (name, paramNames) => { const o = { functionName: name, module: '${moduleName}', trackArgs: true, trackReturn: true, sampleRate: 1, maxDepth: 5, environment: process.env.TRICKLE_ENV || 'development', enabled: true }; if (paramNames && paramNames.length) o.paramNames = paramNames; return o; };`);
+  }
 
   // For in-place wrapping: insert wrapper calls right after each function declaration
   // This ensures functions are wrapped BEFORE any top-level code calls them
@@ -726,17 +808,61 @@ function transformSource(source, url, originalSource) {
     result.push(`export default __trickle_default_wrapped;`);
   }
 
+  // Inject framework instrumentation if detected
+  if (frameworkInjects.length > 0) {
+    for (const fi of frameworkInjects) {
+      const instrumentFn = fi.framework === 'express' ? 'instrumentExpress'
+        : fi.framework === 'fastify' ? 'instrumentFastify'
+        : fi.framework === 'koa' ? 'instrumentKoa'
+        : 'instrumentHono';
+      const fiPath = fi.importPath.replace(/\\/g, '\\\\');
+      // Find where the app is created and inject after
+      const appPattern = new RegExp(`(?:const|let|var)\\s+${fi.appVar}\\s*=`);
+      for (let ri = 0; ri < result.length; ri++) {
+        if (appPattern.test(result[ri])) {
+          let endLine = ri;
+          let depth = 0;
+          for (let j = ri; j < result.length; j++) {
+            for (const ch of result[j]) {
+              if (ch === '(' || ch === '{' || ch === '[') depth++;
+              if (ch === ')' || ch === '}' || ch === ']') depth--;
+            }
+            if (result[j].includes(';') && depth <= 0) { endLine = j; break; }
+            if (j > ri && depth <= 0) { endLine = j - 1; break; }
+          }
+          // We need to inject BEFORE routes are defined. Since __require from wrapSetup
+      // may not be initialized yet, we add a separate import + require pair.
+      // ESM import declarations are hoisted, so this import is available immediately.
+      // We use __cr_fw (unique name) to avoid conflicts with other createRequire imports.
+      const crImportLine = `import { createRequire as __cr_fw_${fi.framework} } from 'node:module';`;
+      // Insert the import at the very beginning of result
+      result.unshift(crImportLine);
+      // The endLine index shifted by 1 due to unshift
+      result.splice(endLine + 2, 0,
+        `try { const __rq_fw = __cr_fw_${fi.framework}(import.meta.url); const __fw = __rq_fw('${fiPath}'); __fw.${instrumentFn}(${fi.appVar}, { environment: process.env.TRICKLE_ENV || 'development' }); } catch(__e) { if (${config.debug}) console.error('[trickle/esm] Framework injection error:', __e.message); }`
+      );
+          break;
+        }
+      }
+    }
+  }
+
   const transformed = result.join('\n');
 
   if (config.debug) {
     const fnCount = exportedFunctions.length + exportedDefaults.length + namedExports.length;
     const varCount = varDecls.length + destructDecls.length;
-    console.log(`[trickle/esm] Transformed ${fnCount} exports, ${varCount} vars from ${moduleName}`);
+    const fwCount = frameworkInjects.length;
+    console.log(`[trickle/esm] Transformed ${fnCount} exports, ${varCount} vars, ${fwCount} frameworks from ${moduleName}`);
   }
 
   return transformed;
 }
 
+// ── Framework auto-instrumentation for ESM ──
+// ESM imports bypass Module._load, so CJS hooks don't fire.
+// We detect framework imports in user source code and inject instrumentation calls.
+
 /**
  * ESM load hook — intercepts module loading to transform user modules.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.128",
+  "version": "0.2.130",
   "description": "Zero-code runtime observability for JavaScript/TypeScript. Auto-instruments Express, Fastify, Koa, Hono, OpenAI, Anthropic, Gemini, MCP. Captures functions, variables, LLM calls, agent workflows.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/register.ts

@@ -9,8 +9,8 @@
  *
  *   TRICKLE_BACKEND_URL=http://localhost:4888 node -r trickle/register app.js
  *
- * This module patches Node's module loader to intercept `require('express')`
- * and automatically instrument any Express app created — no code changes needed.
+ * This module patches Node's module loader to intercept framework requires
+ * (Express, Fastify, Koa, Hono) and automatically instrument any app created.
  *
  * Supported environment variables:
  *   TRICKLE_BACKEND_URL  — Backend URL (default: http://localhost:4888)
@@ -22,6 +22,9 @@
 import Module from 'module';
 import { configure } from './transport';
 import { instrumentExpress } from './express';
+import { instrumentFastify } from './fastify';
+import { instrumentKoa } from './koa';
+import { instrumentHono } from './hono';
 import { detectEnvironment } from './env-detect';
 
 const M = Module as any;
@@ -33,6 +36,7 @@ const backendUrl = process.env.TRICKLE_BACKEND_URL || 'http://localhost:4888';
 const enabled = process.env.TRICKLE_ENABLED !== '0' && process.env.TRICKLE_ENABLED !== 'false';
 const debug = process.env.TRICKLE_DEBUG === '1' || process.env.TRICKLE_DEBUG === 'true';
 const envOverride = process.env.TRICKLE_ENV || undefined;
+const environment = envOverride || detectEnvironment();
 
 if (enabled) {
   // Configure the transport
@@ -41,7 +45,7 @@ if (enabled) {
     batchIntervalMs: 2000,
     debug,
     enabled: true,
-    environment: envOverride || detectEnvironment(),
+    environment,
   });
 
   if (debug) {
@@ -58,6 +62,24 @@ if (enabled) {
       return patchExpress(exports, request, parent);
     }
 
+    // Intercept require('fastify')
+    if (request === 'fastify' && !patched.has('fastify')) {
+      patched.add('fastify');
+      return patchFastify(exports, request, parent);
+    }
+
+    // Intercept require('koa')
+    if (request === 'koa' && !patched.has('koa')) {
+      patched.add('koa');
+      return patchKoa(exports, request, parent);
+    }
+
+    // Intercept require('hono')
+    if (request === 'hono' && !patched.has('hono')) {
+      patched.add('hono');
+      return patchHono(exports, request, parent);
+    }
+
     return exports;
   };
 } else if (debug) {
@@ -66,15 +88,12 @@ if (enabled) {
 
 /**
  * Wrap the Express factory function so every app created is auto-instrumented.
- * Preserves all static properties (express.json, express.static, etc.).
  */
 function patchExpress(originalExpress: any, request: string, parent: any): any {
   function wrappedExpress(this: any, ...args: any[]): any {
     const app = originalExpress.apply(this, args);
     try {
-      instrumentExpress(app, {
-        environment: envOverride || detectEnvironment(),
-      });
+      instrumentExpress(app, { environment });
       if (debug) {
         console.log('[trickle] Auto-instrumented Express app');
       }
@@ -87,24 +106,120 @@ function patchExpress(originalExpress: any, request: string, parent: any): any {
     return app;
   }
 
-  // Copy all static properties (express.json, express.static, express.Router, etc.)
   for (const key of Object.keys(originalExpress)) {
     (wrappedExpress as any)[key] = originalExpress[key];
   }
-
-  // Preserve prototype chain
   Object.setPrototypeOf(wrappedExpress, Object.getPrototypeOf(originalExpress));
 
-  // Update require cache so subsequent require('express') returns the patched version
   try {
     const resolvedPath = M._resolveFilename(request, parent);
     if (require.cache[resolvedPath]) {
       require.cache[resolvedPath]!.exports = wrappedExpress;
     }
-  } catch {
-    // Cache update failed — first require still returns patched, but subsequent
-    // requires from other modules may get the original. This is rare.
-  }
+  } catch {}
 
   return wrappedExpress;
 }
+
+/**
+ * Wrap the Fastify factory function.
+ */
+function patchFastify(origExports: any, request: string, parent: any): any {
+  const factory = typeof origExports === 'function' ? origExports : origExports.default || origExports.fastify;
+  if (typeof factory !== 'function') return origExports;
+
+  const wrappedFactory = function (this: any, ...args: any[]): any {
+    const app = factory.apply(this, args);
+    try {
+      instrumentFastify(app, { environment });
+      if (debug) console.log('[trickle] Auto-instrumented Fastify app');
+    } catch (err: unknown) {
+      if (debug) console.warn(`[trickle] Failed to auto-instrument Fastify: ${(err as Error).message}`);
+    }
+    return app;
+  };
+
+  for (const key of Object.keys(factory)) {
+    (wrappedFactory as any)[key] = (factory as any)[key];
+  }
+
+  if (typeof origExports === 'function') {
+    try {
+      const resolvedPath = M._resolveFilename(request, parent);
+      if (require.cache[resolvedPath]) require.cache[resolvedPath]!.exports = wrappedFactory;
+    } catch {}
+    return wrappedFactory;
+  }
+
+  const wrapped = { ...origExports };
+  if (origExports.default) wrapped.default = wrappedFactory;
+  if (origExports.fastify) wrapped.fastify = wrappedFactory;
+  return wrapped;
+}
+
+/**
+ * Wrap the Koa constructor.
+ */
+function patchKoa(origExports: any, request: string, parent: any): any {
+  const KoaClass = typeof origExports === 'function' ? origExports : origExports.default;
+  if (typeof KoaClass !== 'function') return origExports;
+
+  const WrappedKoa = function (this: any, ...args: any[]): any {
+    const app = new KoaClass(...args);
+    try {
+      instrumentKoa(app, { environment });
+      if (debug) console.log('[trickle] Auto-instrumented Koa app');
+    } catch (err: unknown) {
+      if (debug) console.warn(`[trickle] Failed to auto-instrument Koa: ${(err as Error).message}`);
+    }
+    return app;
+  };
+  WrappedKoa.prototype = KoaClass.prototype;
+  for (const key of Object.keys(KoaClass)) {
+    (WrappedKoa as any)[key] = (KoaClass as any)[key];
+  }
+
+  if (typeof origExports === 'function') {
+    try {
+      const resolvedPath = M._resolveFilename(request, parent);
+      if (require.cache[resolvedPath]) require.cache[resolvedPath]!.exports = WrappedKoa;
+    } catch {}
+    return WrappedKoa;
+  }
+  return { ...origExports, default: WrappedKoa };
+}
+
+/**
+ * Wrap the Hono constructor.
+ */
+function patchHono(origExports: any, request: string, parent: any): any {
+  const HonoClass = origExports.Hono || (origExports.default && origExports.default.Hono);
+  if (typeof HonoClass !== 'function') return origExports;
+
+  const WrappedHono = function (this: any, ...args: any[]): any {
+    const app = new HonoClass(...args);
+    try {
+      instrumentHono(app, { environment });
+      if (debug) console.log('[trickle] Auto-instrumented Hono app');
+    } catch (err: unknown) {
+      if (debug) console.warn(`[trickle] Failed to auto-instrument Hono: ${(err as Error).message}`);
+    }
+    return app;
+  };
+  WrappedHono.prototype = HonoClass.prototype;
+  for (const key of Object.keys(HonoClass)) {
+    (WrappedHono as any)[key] = (HonoClass as any)[key];
+  }
+
+  const result = { ...origExports, Hono: WrappedHono };
+
+  try {
+    const resolvedPath = M._resolveFilename(request, parent);
+    if (require.cache[resolvedPath]) {
+      const cached = require.cache[resolvedPath]!.exports;
+      if (cached.Hono) cached.Hono = WrappedHono;
+    }
+  } catch {}
+
+  return result;
+}