trickle-observe 0.2.127 → 0.2.128

package/dist/hono.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Instrument a Hono app by monkey-patching route registration methods.
+ *
+ * Must be called BEFORE routes are defined:
+ *
+ *   import { Hono } from 'hono';
+ *   import { instrumentHono } from 'trickle';
+ *
+ *   const app = new Hono();
+ *   instrumentHono(app);
+ *
+ *   app.get('/api/users', (c) => c.json({ users: [] }));
+ *
+ * Captures:
+ * - Input: body (JSON), params, query from the Hono context
+ * - Output: the data passed to c.json() / c.text() or returned directly
+ * - Errors: exceptions thrown in handlers
+ * - Timing: request duration in milliseconds
+ */
+export declare function instrumentHono(app: any, userOpts?: {
+    enabled?: boolean;
+    environment?: string;
+    sampleRate?: number;
+    maxDepth?: number;
+}): void;
+/**
+ * Hono middleware for observability. Use this as an alternative to
+ * monkey-patching route methods:
+ *
+ *   import { Hono } from 'hono';
+ *   import { trickleHonoMiddleware } from 'trickle';
+ *
+ *   const app = new Hono();
+ *   app.use('*', trickleHonoMiddleware());
+ */
+export declare function trickleHonoMiddleware(userOpts?: {
+    enabled?: boolean;
+    environment?: string;
+    sampleRate?: number;
+    maxDepth?: number;
+}): (c: any, next: () => Promise<void>) => Promise<void | Response>;

package/dist/hono.js

@@ -0,0 +1,396 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentHono = instrumentHono;
+exports.trickleHonoMiddleware = trickleHonoMiddleware;
+const fs = __importStar(require("fs"));
+const pathMod = __importStar(require("path"));
+const type_inference_1 = require("./type-inference");
+const type_hash_1 = require("./type-hash");
+const cache_1 = require("./cache");
+const transport_1 = require("./transport");
+const env_detect_1 = require("./env-detect");
+const call_trace_1 = require("./call-trace");
+const honoCache = new cache_1.TypeCache();
+// ── Input extraction ──
+async function extractHonoInput(c) {
+    const input = {};
+    try {
+        // Hono body: c.req.json() / c.req.text() — need to clone to avoid consuming
+        const contentType = c.req.header('content-type') || '';
+        if (contentType.includes('application/json')) {
+            try {
+                const body = await c.req.json();
+                if (body && typeof body === 'object' && Object.keys(body).length > 0) {
+                    input.body = body;
+                }
+            }
+            catch { /* body may not be parseable */ }
+        }
+    }
+    catch { }
+    try {
+        // c.req.param() returns all params as an object
+        const params = c.req.param();
+        if (params && typeof params === 'object' && Object.keys(params).length > 0) {
+            input.params = params;
+        }
+    }
+    catch { }
+    try {
+        // c.req.query() returns all query params
+        const query = c.req.query();
+        if (query && typeof query === 'object' && Object.keys(query).length > 0) {
+            input.query = query;
+        }
+    }
+    catch { }
+    return input;
+}
+// ── Sample sanitization (local copy) ──
+function sanitizeSample(value, depth = 3) {
+    if (depth <= 0)
+        return '[truncated]';
+    if (value === null || value === undefined)
+        return value;
+    const t = typeof value;
+    if (t === 'string') {
+        const s = value;
+        return s.length > 200 ? s.substring(0, 200) + '...' : s;
+    }
+    if (t === 'number' || t === 'boolean')
+        return value;
+    if (t === 'bigint')
+        return String(value);
+    if (t === 'function')
+        return `[Function: ${value.name || 'anonymous'}]`;
+    if (Array.isArray(value)) {
+        return value.slice(0, 5).map(item => sanitizeSample(item, depth - 1));
+    }
+    if (t === 'object') {
+        if (value instanceof Date)
+            return value.toISOString();
+        if (value instanceof Error)
+            return { error: value.message };
+        if (value instanceof Map)
+            return `[Map: ${value.size} entries]`;
+        if (value instanceof Set)
+            return `[Set: ${value.size} items]`;
+        const obj = value;
+        const result = {};
+        const keys = Object.keys(obj).slice(0, 20);
+        for (const key of keys) {
+            try {
+                result[key] = sanitizeSample(obj[key], depth - 1);
+            }
+            catch {
+                result[key] = '[unreadable]';
+            }
+        }
+        return result;
+    }
+    return String(value);
+}
+// ── Error file writing ──
+function writeErrorToFile(error, input, routeName) {
+    try {
+        const err = error instanceof Error ? error : new Error(String(error));
+        const defaultDir = pathMod.join(process.cwd(), '.trickle');
+        const dir = process.env.TRICKLE_LOCAL_DIR || defaultDir;
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        catch { }
+        const stackLines = (err.stack || '').split('\n');
+        let errorFile;
+        let errorLine;
+        for (const sl of stackLines.slice(1)) {
+            const m = sl.match(/\((.+):(\d+):\d+\)/) || sl.match(/at (.+):(\d+):\d+/);
+            if (m && !m[1].includes('node_modules') && !m[1].includes('node:') && !m[1].includes('trickle-observe')) {
+                errorFile = m[1];
+                errorLine = parseInt(m[2]);
+                break;
+            }
+        }
+        const record = {
+            kind: 'error',
+            error: err.message,
+            type: err.constructor?.name || 'Error',
+            message: err.message,
+            file: errorFile,
+            line: errorLine,
+            stack: stackLines.slice(0, 6).join('\n'),
+            route: routeName,
+            request: input,
+            timestamp: new Date().toISOString(),
+        };
+        fs.appendFileSync(pathMod.join(dir, 'errors.jsonl'), JSON.stringify(record) + '\n');
+    }
+    catch {
+        // Never crash the user's app
+    }
+}
+// ── Payload emission ──
+function emitHonoPayload(functionName, environment, maxDepth, input, output, error, durationMs) {
+    try {
+        const functionKey = `hono::${functionName}`;
+        const argsType = (0, type_inference_1.inferType)(input, maxDepth);
+        const returnType = error ? { kind: 'unknown' } : (0, type_inference_1.inferType)(output, maxDepth);
+        const hash = (0, type_hash_1.hashType)(argsType, returnType);
+        if (!error && !honoCache.shouldSend(functionKey, hash))
+            return;
+        if (!error)
+            honoCache.markSent(functionKey, hash);
+        const payload = {
+            functionName,
+            module: 'hono',
+            language: 'js',
+            environment,
+            typeHash: hash,
+            argsType,
+            returnType,
+            sampleInput: sanitizeSample(input),
+            sampleOutput: error ? undefined : sanitizeSample(output),
+        };
+        if (durationMs !== undefined) {
+            payload.durationMs = Math.round(durationMs * 100) / 100;
+        }
+        if (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            payload.error = {
+                type: err.constructor?.name || 'Error',
+                message: err.message,
+                stackTrace: err.stack,
+                argsSnapshot: sanitizeSample(input),
+            };
+            writeErrorToFile(error, input, functionName);
+        }
+        (0, transport_1.enqueue)(payload);
+    }
+    catch {
+        // Never crash the user's app
+    }
+}
+// ── Public API ──
+/**
+ * Instrument a Hono app by monkey-patching route registration methods.
+ *
+ * Must be called BEFORE routes are defined:
+ *
+ *   import { Hono } from 'hono';
+ *   import { instrumentHono } from 'trickle';
+ *
+ *   const app = new Hono();
+ *   instrumentHono(app);
+ *
+ *   app.get('/api/users', (c) => c.json({ users: [] }));
+ *
+ * Captures:
+ * - Input: body (JSON), params, query from the Hono context
+ * - Output: the data passed to c.json() / c.text() or returned directly
+ * - Errors: exceptions thrown in handlers
+ * - Timing: request duration in milliseconds
+ */
+function instrumentHono(app, userOpts) {
+    const opts = {
+        enabled: userOpts?.enabled !== false,
+        environment: userOpts?.environment || (0, env_detect_1.detectEnvironment)(),
+        sampleRate: userOpts?.sampleRate ?? 1,
+        maxDepth: userOpts?.maxDepth ?? 5,
+    };
+    if (!opts.enabled)
+        return;
+    const methods = ['get', 'post', 'put', 'delete', 'patch', 'all', 'options', 'head'];
+    for (const method of methods) {
+        const original = app[method];
+        if (typeof original !== 'function')
+            continue;
+        app[method] = function (path, ...handlers) {
+            const pathStr = typeof path === 'string' ? path : String(path);
+            const routeName = `${method.toUpperCase()} ${pathStr}`;
+            const wrapped = handlers.map((handler) => {
+                if (typeof handler !== 'function')
+                    return handler;
+                return wrapHonoHandler(handler, routeName, opts);
+            });
+            return original.call(this, path, ...wrapped);
+        };
+    }
+}
+function wrapHonoHandler(handler, routeName, opts) {
+    const wrapped = async function (c, next) {
+        // Sample rate check
+        if (opts.sampleRate < 1 && Math.random() > opts.sampleRate) {
+            return handler.call(this, c, next);
+        }
+        const startTime = performance.now();
+        const callId = (0, call_trace_1.traceCall)(routeName, 'hono');
+        // Extract input (async because body parsing is async in Hono)
+        let input = {};
+        try {
+            input = await extractHonoInput(c);
+        }
+        catch { }
+        // Intercept c.json() to capture output
+        let captured = false;
+        const originalJson = c.json;
+        if (typeof originalJson === 'function') {
+            c.json = function (data, ...args) {
+                if (!captured) {
+                    captured = true;
+                    const durationMs = performance.now() - startTime;
+                    (0, call_trace_1.traceReturn)(callId, routeName, 'hono', durationMs);
+                    emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, data, undefined, durationMs);
+                }
+                return originalJson.call(c, data, ...args);
+            };
+        }
+        // Intercept c.text() for text responses
+        const originalText = c.text;
+        if (typeof originalText === 'function') {
+            c.text = function (data, ...args) {
+                if (!captured) {
+                    captured = true;
+                    const durationMs = performance.now() - startTime;
+                    (0, call_trace_1.traceReturn)(callId, routeName, 'hono', durationMs);
+                    emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, { __text: true }, undefined, durationMs);
+                }
+                return originalText.call(c, data, ...args);
+            };
+        }
+        try {
+            const result = await handler.call(this, c, next);
+            // Hono handlers can return a Response object directly
+            if (result && !captured) {
+                captured = true;
+                const durationMs = performance.now() - startTime;
+                (0, call_trace_1.traceReturn)(callId, routeName, 'hono', durationMs);
+                // Try to extract JSON from the Response
+                if (result instanceof Response) {
+                    try {
+                        const cloned = result.clone();
+                        const ct = cloned.headers.get('content-type') || '';
+                        if (ct.includes('application/json')) {
+                            const body = await cloned.json();
+                            emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, body, undefined, durationMs);
+                        }
+                        else {
+                            emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, { __response: true }, undefined, durationMs);
+                        }
+                    }
+                    catch {
+                        emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, { __response: true }, undefined, durationMs);
+                    }
+                }
+                else {
+                    emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, result, undefined, durationMs);
+                }
+            }
+            return result;
+        }
+        catch (err) {
+            if (!captured) {
+                captured = true;
+                const durationMs = performance.now() - startTime;
+                (0, call_trace_1.traceReturn)(callId, routeName, 'hono', durationMs, (err instanceof Error ? err : new Error(String(err))).message);
+                emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err, durationMs);
+            }
+            throw err;
+        }
+    };
+    Object.defineProperty(wrapped, 'name', { value: handler.name || routeName, configurable: true });
+    Object.defineProperty(wrapped, 'length', { value: handler.length, configurable: true });
+    return wrapped;
+}
+/**
+ * Hono middleware for observability. Use this as an alternative to
+ * monkey-patching route methods:
+ *
+ *   import { Hono } from 'hono';
+ *   import { trickleHonoMiddleware } from 'trickle';
+ *
+ *   const app = new Hono();
+ *   app.use('*', trickleHonoMiddleware());
+ */
+function trickleHonoMiddleware(userOpts) {
+    const opts = {
+        enabled: userOpts?.enabled !== false,
+        environment: userOpts?.environment || (0, env_detect_1.detectEnvironment)(),
+        sampleRate: userOpts?.sampleRate ?? 1,
+        maxDepth: userOpts?.maxDepth ?? 5,
+    };
+    return async function trickleHonoMw(c, next) {
+        if (!opts.enabled)
+            return next();
+        if (opts.sampleRate < 1 && Math.random() > opts.sampleRate)
+            return next();
+        const startTime = performance.now();
+        const routeName = `${c.req.method} ${c.req.path}`;
+        const callId = (0, call_trace_1.traceCall)(routeName, 'hono');
+        let input = {};
+        try {
+            input = await extractHonoInput(c);
+        }
+        catch { }
+        try {
+            await next();
+            const durationMs = performance.now() - startTime;
+            (0, call_trace_1.traceReturn)(callId, routeName, 'hono', durationMs);
+            // After next(), capture from c.res if available
+            if (c.res) {
+                try {
+                    const ct = c.res.headers?.get('content-type') || '';
+                    if (ct.includes('application/json')) {
+                        const cloned = c.res.clone();
+                        const body = await cloned.json();
+                        emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, body, undefined, durationMs);
+                    }
+                    else {
+                        emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, { __response: true }, undefined, durationMs);
+                    }
+                }
+                catch {
+                    emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, { __response: true }, undefined, durationMs);
+                }
+            }
+        }
+        catch (err) {
+            const durationMs = performance.now() - startTime;
+            (0, call_trace_1.traceReturn)(callId, routeName, 'hono', durationMs, (err instanceof Error ? err : new Error(String(err))).message);
+            emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err, durationMs);
+            throw err;
+        }
+    };
+}

package/dist/index.d.ts

@@ -42,7 +42,7 @@ export declare function trickleExpress(app: any, opts?: {
     maxDepth?: number;
 }): void;
 /**
- * Auto-instrument a framework app. Supports Express, Fastify, and Koa.
+ * Auto-instrument a framework app. Supports Express, Fastify, Koa, and Hono.
  *
  * Usage:
  *   import { instrument } from 'trickle';
@@ -64,6 +64,7 @@ export { flush } from './transport';
 export { instrumentExpress, trickleMiddleware } from './express';
 export { instrumentFastify, tricklePlugin } from './fastify';
 export { instrumentKoa, instrumentKoaRouter } from './koa';
+export { instrumentHono, trickleHonoMiddleware } from './hono';
 export { observe, observeFn } from './observe';
 export type { ObserveOpts } from './observe';
 export { wrapFunction } from './wrap';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapFunction = exports.observeFn = exports.observe = exports.instrumentKoaRouter = exports.instrumentKoa = exports.tricklePlugin = exports.instrumentFastify = exports.trickleMiddleware = exports.instrumentExpress = exports.flush = void 0;
+exports.wrapFunction = exports.observeFn = exports.observe = exports.trickleHonoMiddleware = exports.instrumentHono = exports.instrumentKoaRouter = exports.instrumentKoa = exports.tricklePlugin = exports.instrumentFastify = exports.trickleMiddleware = exports.instrumentExpress = exports.flush = void 0;
 exports.configure = configure;
 exports.trickle = trickle;
 exports.trickleHandler = trickleHandler;
@@ -12,6 +12,7 @@ const env_detect_1 = require("./env-detect");
 const express_1 = require("./express");
 const fastify_1 = require("./fastify");
 const koa_1 = require("./koa");
+const hono_1 = require("./hono");
 let globalOpts = {
     backendUrl: 'http://localhost:4888',
     batchIntervalMs: 2000,
@@ -110,7 +111,7 @@ function trickleExpress(app, opts) {
     });
 }
 /**
- * Auto-instrument a framework app. Supports Express, Fastify, and Koa.
+ * Auto-instrument a framework app. Supports Express, Fastify, Koa, and Hono.
  *
  * Usage:
  *   import { instrument } from 'trickle';
@@ -134,6 +135,12 @@ function instrument(app, opts) {
         sampleRate: opts?.sampleRate ?? 1,
         maxDepth: opts?.maxDepth ?? 5,
     };
+    // Detect Hono: has .fetch (bound method), .route(), .get(), but NOT .listen() on the app itself
+    // Hono apps use serve() from @hono/node-server rather than app.listen()
+    if (typeof app.fetch === 'function' && typeof app.get === 'function' && typeof app.route === 'function' && typeof app.fire === 'function') {
+        (0, hono_1.instrumentHono)(app, mergedOpts);
+        return;
+    }
     // Detect Fastify: has .route(), .register(), .addHook()
     if (typeof app.route === 'function' && typeof app.register === 'function' && typeof app.addHook === 'function') {
         (0, fastify_1.instrumentFastify)(app, mergedOpts);
@@ -199,6 +206,9 @@ Object.defineProperty(exports, "tricklePlugin", { enumerable: true, get: functio
 var koa_2 = require("./koa");
 Object.defineProperty(exports, "instrumentKoa", { enumerable: true, get: function () { return koa_2.instrumentKoa; } });
 Object.defineProperty(exports, "instrumentKoaRouter", { enumerable: true, get: function () { return koa_2.instrumentKoaRouter; } });
+var hono_2 = require("./hono");
+Object.defineProperty(exports, "instrumentHono", { enumerable: true, get: function () { return hono_2.instrumentHono; } });
+Object.defineProperty(exports, "trickleHonoMiddleware", { enumerable: true, get: function () { return hono_2.trickleHonoMiddleware; } });
 var observe_1 = require("./observe");
 Object.defineProperty(exports, "observe", { enumerable: true, get: function () { return observe_1.observe; } });
 Object.defineProperty(exports, "observeFn", { enumerable: true, get: function () { return observe_1.observeFn; } });

package/dist/observe-register.js

@@ -41,6 +41,7 @@ const fetch_observer_1 = require("./fetch-observer");
 const express_1 = require("./express");
 const fastify_1 = require("./fastify");
 const koa_1 = require("./koa");
+const hono_1 = require("./hono");
 const trace_var_1 = require("./trace-var");
 const call_trace_1 = require("./call-trace");
 const llm_observer_1 = require("./llm-observer");
@@ -1502,6 +1503,49 @@ if (enabled) {
             }
             catch { /* fall through */ }
         }
+        // ── Hono auto-detection ──
+        if (request === 'hono' && !expressPatched.has('hono')) {
+            expressPatched.add('hono');
+            try {
+                const honoMod = exports;
+                const HonoClass = honoMod.Hono || (honoMod.default && honoMod.default.Hono);
+                if (HonoClass && typeof HonoClass === 'function') {
+                    const OrigHono = HonoClass;
+                    const WrappedHono = function (...args) {
+                        const app = new OrigHono(...args);
+                        try {
+                            (0, hono_1.instrumentHono)(app, { environment });
+                            if (debug) {
+                                console.log('[trickle/observe] Auto-instrumented Hono app');
+                            }
+                        }
+                        catch (e) {
+                            if (debug) {
+                                console.log('[trickle/observe] Hono instrumentation error:', e.message);
+                            }
+                        }
+                        return app;
+                    };
+                    WrappedHono.prototype = OrigHono.prototype;
+                    for (const key of Object.keys(OrigHono)) {
+                        WrappedHono[key] = OrigHono[key];
+                    }
+                    if (honoMod.Hono) {
+                        honoMod.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 { /* non-critical */ }
+                }
+            }
+            catch { /* fall through */ }
+        }
         // ── Database auto-detection: patch database drivers to capture SQL queries ──
         if (request === 'pg' && !expressPatched.has('pg')) {
             expressPatched.add('pg');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.127",
-  "description": "Zero-code runtime observability for JavaScript/TypeScript. Auto-instruments Express, Fastify, Koa, OpenAI, Anthropic, Gemini, MCP. Captures functions, variables, LLM calls, agent workflows.",
+  "version": "0.2.128",
+  "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",
   "exports": {

package/src/hono.ts

@@ -0,0 +1,403 @@
+import * as fs from 'fs';
+import * as pathMod from 'path';
+import { TypeNode, IngestPayload } from './types';
+import { inferType } from './type-inference';
+import { hashType } from './type-hash';
+import { TypeCache } from './cache';
+import { enqueue } from './transport';
+import { detectEnvironment } from './env-detect';
+import { withRequestContext } from './request-context';
+import { traceCall, traceReturn } from './call-trace';
+
+const honoCache = new TypeCache();
+
+interface HonoInstrumentOpts {
+  enabled: boolean;
+  environment: string;
+  sampleRate: number;
+  maxDepth: number;
+}
+
+// ── Input extraction ──
+
+async function extractHonoInput(c: any): Promise<Record<string, unknown>> {
+  const input: Record<string, unknown> = {};
+
+  try {
+    // Hono body: c.req.json() / c.req.text() — need to clone to avoid consuming
+    const contentType = c.req.header('content-type') || '';
+    if (contentType.includes('application/json')) {
+      try {
+        const body = await c.req.json();
+        if (body && typeof body === 'object' && Object.keys(body).length > 0) {
+          input.body = body;
+        }
+      } catch { /* body may not be parseable */ }
+    }
+  } catch {}
+
+  try {
+    // c.req.param() returns all params as an object
+    const params = c.req.param();
+    if (params && typeof params === 'object' && Object.keys(params).length > 0) {
+      input.params = params;
+    }
+  } catch {}
+
+  try {
+    // c.req.query() returns all query params
+    const query = c.req.query();
+    if (query && typeof query === 'object' && Object.keys(query).length > 0) {
+      input.query = query;
+    }
+  } catch {}
+
+  return input;
+}
+
+// ── Sample sanitization (local copy) ──
+
+function sanitizeSample(value: unknown, depth: number = 3): unknown {
+  if (depth <= 0) return '[truncated]';
+  if (value === null || value === undefined) return value;
+
+  const t = typeof value;
+  if (t === 'string') {
+    const s = value as string;
+    return s.length > 200 ? s.substring(0, 200) + '...' : s;
+  }
+  if (t === 'number' || t === 'boolean') return value;
+  if (t === 'bigint') return String(value);
+  if (t === 'function') return `[Function: ${(value as Function).name || 'anonymous'}]`;
+
+  if (Array.isArray(value)) {
+    return value.slice(0, 5).map(item => sanitizeSample(item, depth - 1));
+  }
+
+  if (t === 'object') {
+    if (value instanceof Date) return value.toISOString();
+    if (value instanceof Error) return { error: value.message };
+    if (value instanceof Map) return `[Map: ${value.size} entries]`;
+    if (value instanceof Set) return `[Set: ${value.size} items]`;
+
+    const obj = value as Record<string, unknown>;
+    const result: Record<string, unknown> = {};
+    const keys = Object.keys(obj).slice(0, 20);
+    for (const key of keys) {
+      try {
+        result[key] = sanitizeSample(obj[key], depth - 1);
+      } catch {
+        result[key] = '[unreadable]';
+      }
+    }
+    return result;
+  }
+
+  return String(value);
+}
+
+// ── Error file writing ──
+
+function writeErrorToFile(error: unknown, input: Record<string, unknown>, routeName: string): void {
+  try {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const defaultDir = pathMod.join(process.cwd(), '.trickle');
+    const dir = process.env.TRICKLE_LOCAL_DIR || defaultDir;
+    try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+
+    const stackLines = (err.stack || '').split('\n');
+    let errorFile: string | undefined;
+    let errorLine: number | undefined;
+    for (const sl of stackLines.slice(1)) {
+      const m = sl.match(/\((.+):(\d+):\d+\)/) || sl.match(/at (.+):(\d+):\d+/);
+      if (m && !m[1].includes('node_modules') && !m[1].includes('node:') && !m[1].includes('trickle-observe')) {
+        errorFile = m[1];
+        errorLine = parseInt(m[2]);
+        break;
+      }
+    }
+
+    const record = {
+      kind: 'error',
+      error: err.message,
+      type: err.constructor?.name || 'Error',
+      message: err.message,
+      file: errorFile,
+      line: errorLine,
+      stack: stackLines.slice(0, 6).join('\n'),
+      route: routeName,
+      request: input,
+      timestamp: new Date().toISOString(),
+    };
+
+    fs.appendFileSync(pathMod.join(dir, 'errors.jsonl'), JSON.stringify(record) + '\n');
+  } catch {
+    // Never crash the user's app
+  }
+}
+
+// ── Payload emission ──
+
+function emitHonoPayload(
+  functionName: string,
+  environment: string,
+  maxDepth: number,
+  input: Record<string, unknown>,
+  output: unknown,
+  error?: unknown,
+  durationMs?: number,
+): void {
+  try {
+    const functionKey = `hono::${functionName}`;
+    const argsType = inferType(input, maxDepth);
+    const returnType = error ? ({ kind: 'unknown' } as TypeNode) : inferType(output, maxDepth);
+    const hash = hashType(argsType, returnType);
+
+    if (!error && !honoCache.shouldSend(functionKey, hash)) return;
+    if (!error) honoCache.markSent(functionKey, hash);
+
+    const payload: IngestPayload = {
+      functionName,
+      module: 'hono',
+      language: 'js',
+      environment,
+      typeHash: hash,
+      argsType,
+      returnType,
+      sampleInput: sanitizeSample(input),
+      sampleOutput: error ? undefined : sanitizeSample(output),
+    };
+
+    if (durationMs !== undefined) {
+      payload.durationMs = Math.round(durationMs * 100) / 100;
+    }
+
+    if (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      payload.error = {
+        type: err.constructor?.name || 'Error',
+        message: err.message,
+        stackTrace: err.stack,
+        argsSnapshot: sanitizeSample(input),
+      };
+      writeErrorToFile(error, input, functionName);
+    }
+
+    enqueue(payload);
+  } catch {
+    // Never crash the user's app
+  }
+}
+
+// ── Public API ──
+
+/**
+ * Instrument a Hono app by monkey-patching route registration methods.
+ *
+ * Must be called BEFORE routes are defined:
+ *
+ *   import { Hono } from 'hono';
+ *   import { instrumentHono } from 'trickle';
+ *
+ *   const app = new Hono();
+ *   instrumentHono(app);
+ *
+ *   app.get('/api/users', (c) => c.json({ users: [] }));
+ *
+ * Captures:
+ * - Input: body (JSON), params, query from the Hono context
+ * - Output: the data passed to c.json() / c.text() or returned directly
+ * - Errors: exceptions thrown in handlers
+ * - Timing: request duration in milliseconds
+ */
+export function instrumentHono(
+  app: any,
+  userOpts?: { enabled?: boolean; environment?: string; sampleRate?: number; maxDepth?: number },
+): void {
+  const opts: HonoInstrumentOpts = {
+    enabled: userOpts?.enabled !== false,
+    environment: userOpts?.environment || detectEnvironment(),
+    sampleRate: userOpts?.sampleRate ?? 1,
+    maxDepth: userOpts?.maxDepth ?? 5,
+  };
+
+  if (!opts.enabled) return;
+
+  const methods = ['get', 'post', 'put', 'delete', 'patch', 'all', 'options', 'head'] as const;
+
+  for (const method of methods) {
+    const original = app[method];
+    if (typeof original !== 'function') continue;
+
+    app[method] = function (this: any, path: string, ...handlers: any[]) {
+      const pathStr = typeof path === 'string' ? path : String(path);
+      const routeName = `${method.toUpperCase()} ${pathStr}`;
+
+      const wrapped = handlers.map((handler: any) => {
+        if (typeof handler !== 'function') return handler;
+
+        return wrapHonoHandler(handler, routeName, opts);
+      });
+
+      return original.call(this, path, ...wrapped);
+    };
+  }
+}
+
+function wrapHonoHandler(
+  handler: Function,
+  routeName: string,
+  opts: HonoInstrumentOpts,
+): Function {
+  const wrapped = async function (this: any, c: any, next?: any) {
+    // Sample rate check
+    if (opts.sampleRate < 1 && Math.random() > opts.sampleRate) {
+      return handler.call(this, c, next);
+    }
+
+    const startTime = performance.now();
+    const callId = traceCall(routeName, 'hono');
+
+    // Extract input (async because body parsing is async in Hono)
+    let input: Record<string, unknown> = {};
+    try {
+      input = await extractHonoInput(c);
+    } catch {}
+
+    // Intercept c.json() to capture output
+    let captured = false;
+    const originalJson = c.json;
+    if (typeof originalJson === 'function') {
+      c.json = function (data: any, ...args: any[]) {
+        if (!captured) {
+          captured = true;
+          const durationMs = performance.now() - startTime;
+          traceReturn(callId, routeName, 'hono', durationMs);
+          emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, data, undefined, durationMs);
+        }
+        return originalJson.call(c, data, ...args);
+      };
+    }
+
+    // Intercept c.text() for text responses
+    const originalText = c.text;
+    if (typeof originalText === 'function') {
+      c.text = function (data: any, ...args: any[]) {
+        if (!captured) {
+          captured = true;
+          const durationMs = performance.now() - startTime;
+          traceReturn(callId, routeName, 'hono', durationMs);
+          emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, { __text: true }, undefined, durationMs);
+        }
+        return originalText.call(c, data, ...args);
+      };
+    }
+
+    try {
+      const result = await handler.call(this, c, next);
+
+      // Hono handlers can return a Response object directly
+      if (result && !captured) {
+        captured = true;
+        const durationMs = performance.now() - startTime;
+        traceReturn(callId, routeName, 'hono', durationMs);
+
+        // Try to extract JSON from the Response
+        if (result instanceof Response) {
+          try {
+            const cloned = result.clone();
+            const ct = cloned.headers.get('content-type') || '';
+            if (ct.includes('application/json')) {
+              const body = await cloned.json();
+              emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, body, undefined, durationMs);
+            } else {
+              emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, { __response: true }, undefined, durationMs);
+            }
+          } catch {
+            emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, { __response: true }, undefined, durationMs);
+          }
+        } else {
+          emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, result, undefined, durationMs);
+        }
+      }
+
+      return result;
+    } catch (err) {
+      if (!captured) {
+        captured = true;
+        const durationMs = performance.now() - startTime;
+        traceReturn(callId, routeName, 'hono', durationMs, (err instanceof Error ? err : new Error(String(err))).message);
+        emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err, durationMs);
+      }
+      throw err;
+    }
+  };
+
+  Object.defineProperty(wrapped, 'name', { value: handler.name || routeName, configurable: true });
+  Object.defineProperty(wrapped, 'length', { value: handler.length, configurable: true });
+
+  return wrapped;
+}
+
+/**
+ * Hono middleware for observability. Use this as an alternative to
+ * monkey-patching route methods:
+ *
+ *   import { Hono } from 'hono';
+ *   import { trickleHonoMiddleware } from 'trickle';
+ *
+ *   const app = new Hono();
+ *   app.use('*', trickleHonoMiddleware());
+ */
+export function trickleHonoMiddleware(
+  userOpts?: { enabled?: boolean; environment?: string; sampleRate?: number; maxDepth?: number },
+): (c: any, next: () => Promise<void>) => Promise<void | Response> {
+  const opts: HonoInstrumentOpts = {
+    enabled: userOpts?.enabled !== false,
+    environment: userOpts?.environment || detectEnvironment(),
+    sampleRate: userOpts?.sampleRate ?? 1,
+    maxDepth: userOpts?.maxDepth ?? 5,
+  };
+
+  return async function trickleHonoMw(c: any, next: () => Promise<void>): Promise<void | Response> {
+    if (!opts.enabled) return next();
+    if (opts.sampleRate < 1 && Math.random() > opts.sampleRate) return next();
+
+    const startTime = performance.now();
+    const routeName = `${c.req.method} ${c.req.path}`;
+    const callId = traceCall(routeName, 'hono');
+
+    let input: Record<string, unknown> = {};
+    try {
+      input = await extractHonoInput(c);
+    } catch {}
+
+    try {
+      await next();
+
+      const durationMs = performance.now() - startTime;
+      traceReturn(callId, routeName, 'hono', durationMs);
+
+      // After next(), capture from c.res if available
+      if (c.res) {
+        try {
+          const ct = c.res.headers?.get('content-type') || '';
+          if (ct.includes('application/json')) {
+            const cloned = c.res.clone();
+            const body = await cloned.json();
+            emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, body, undefined, durationMs);
+          } else {
+            emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, { __response: true }, undefined, durationMs);
+          }
+        } catch {
+          emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, { __response: true }, undefined, durationMs);
+        }
+      }
+    } catch (err) {
+      const durationMs = performance.now() - startTime;
+      traceReturn(callId, routeName, 'hono', durationMs, (err instanceof Error ? err : new Error(String(err))).message);
+      emitHonoPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err, durationMs);
+      throw err;
+    }
+  };
+}

package/src/index.ts

@@ -5,6 +5,7 @@ import { GlobalOpts, TrickleOpts, WrapOptions } from './types';
 import { instrumentExpress, trickleMiddleware } from './express';
 import { instrumentFastify, tricklePlugin } from './fastify';
 import { instrumentKoa, instrumentKoaRouter } from './koa';
+import { instrumentHono, trickleHonoMiddleware } from './hono';
 
 let globalOpts: GlobalOpts = {
   backendUrl: 'http://localhost:4888',
@@ -135,7 +136,7 @@ export function trickleExpress(
 }
 
 /**
- * Auto-instrument a framework app. Supports Express, Fastify, and Koa.
+ * Auto-instrument a framework app. Supports Express, Fastify, Koa, and Hono.
  *
  * Usage:
  *   import { instrument } from 'trickle';
@@ -164,6 +165,13 @@ export function instrument(
     maxDepth: opts?.maxDepth ?? 5,
   };
 
+  // Detect Hono: has .fetch (bound method), .route(), .get(), but NOT .listen() on the app itself
+  // Hono apps use serve() from @hono/node-server rather than app.listen()
+  if (typeof app.fetch === 'function' && typeof app.get === 'function' && typeof app.route === 'function' && typeof app.fire === 'function') {
+    instrumentHono(app, mergedOpts);
+    return;
+  }
+
   // Detect Fastify: has .route(), .register(), .addHook()
   if (typeof app.route === 'function' && typeof app.register === 'function' && typeof app.addHook === 'function') {
     instrumentFastify(app, mergedOpts);
@@ -227,6 +235,7 @@ export { flush } from './transport';
 export { instrumentExpress, trickleMiddleware } from './express';
 export { instrumentFastify, tricklePlugin } from './fastify';
 export { instrumentKoa, instrumentKoaRouter } from './koa';
+export { instrumentHono, trickleHonoMiddleware } from './hono';
 export { observe, observeFn } from './observe';
 export type { ObserveOpts } from './observe';
 export { wrapFunction } from './wrap';

package/src/observe-register.ts

@@ -38,6 +38,7 @@ import { patchFetch } from './fetch-observer';
 import { instrumentExpress, trickleMiddleware } from './express';
 import { instrumentFastify } from './fastify';
 import { instrumentKoa } from './koa';
+import { instrumentHono } from './hono';
 import { initVarTracer, traceVar } from './trace-var';
 import { initCallTrace } from './call-trace';
 import { initLlmObserver } from './llm-observer';
@@ -1483,6 +1484,47 @@ if (enabled) {
       } catch { /* fall through */ }
     }
 
+    // ── Hono auto-detection ──
+    if (request === 'hono' && !expressPatched.has('hono')) {
+      expressPatched.add('hono');
+      try {
+        const honoMod = exports;
+        const HonoClass = honoMod.Hono || (honoMod.default && honoMod.default.Hono);
+        if (HonoClass && typeof HonoClass === 'function') {
+          const OrigHono = HonoClass;
+          const WrappedHono = function (this: any, ...args: any[]): any {
+            const app = new OrigHono(...args);
+            try {
+              instrumentHono(app, { environment });
+              if (debug) {
+                console.log('[trickle/observe] Auto-instrumented Hono app');
+              }
+            } catch (e: unknown) {
+              if (debug) {
+                console.log('[trickle/observe] Hono instrumentation error:', (e as Error).message);
+              }
+            }
+            return app;
+          };
+          WrappedHono.prototype = OrigHono.prototype;
+          for (const key of Object.keys(OrigHono)) {
+            (WrappedHono as any)[key] = (OrigHono as any)[key];
+          }
+
+          if (honoMod.Hono) {
+            honoMod.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 { /* non-critical */ }
+        }
+      } catch { /* fall through */ }
+    }
+
     // ── Database auto-detection: patch database drivers to capture SQL queries ──
     if (request === 'pg' && !expressPatched.has('pg')) {
       expressPatched.add('pg');