trickle-observe 0.2.128 → 0.2.129

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.128",
+  "version": "0.2.129",
   "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;
+}