trickle-observe 0.2.108 → 0.2.110

package/dist/express.js

@@ -181,6 +181,11 @@ function wrapExpressHandler(handler, routeName, opts) {
                 return next(err);
             }
         };
+        const debug = process.env.TRICKLE_DEBUG === '1';
+        if (debug) {
+            const hs = handler.toString().substring(0, 200);
+            process.stderr.write(`[trickle/express-wrap] Calling handler: ${hs.replace(/\n/g, '\\n')}\n`);
+        }
         try {
             const result = handler.call(this, req, res, wrappedNext);
             // Handle async handlers that return a promise

package/dist/log-observer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Structured log observer — patches popular Node.js logging libraries
+ * to capture structured log entries with context.
+ *
+ * Supports:
+ *   - winston (most popular Node.js logger, 13M weekly downloads)
+ *   - pino (fastest Node.js logger, 5M weekly downloads)
+ *   - bunyan (legacy but still used, 1M weekly downloads)
+ *
+ * Writes to .trickle/logs.jsonl as:
+ *   { "kind": "log", "level": "error", "logger": "winston",
+ *     "message": "User not found", "timestamp": 1710516000,
+ *     "meta": { "userId": 123 } }
+ */
+/**
+ * Patch winston to capture structured log entries.
+ * Winston uses transports — we add a custom transport that writes to logs.jsonl.
+ */
+export declare function patchWinston(winstonModule: any, debug: boolean): void;
+/**
+ * Patch pino to capture structured log entries.
+ * Pino uses a destination stream — we wrap the pino factory to intercept log calls.
+ */
+export declare function patchPino(pinoModule: any, debug: boolean): void;
+/**
+ * Patch bunyan to capture structured log entries.
+ * Bunyan loggers have addStream() — we add a custom stream.
+ */
+export declare function patchBunyan(bunyanModule: any, debug: boolean): void;

package/dist/log-observer.js

@@ -0,0 +1,331 @@
+"use strict";
+/**
+ * Structured log observer — patches popular Node.js logging libraries
+ * to capture structured log entries with context.
+ *
+ * Supports:
+ *   - winston (most popular Node.js logger, 13M weekly downloads)
+ *   - pino (fastest Node.js logger, 5M weekly downloads)
+ *   - bunyan (legacy but still used, 1M weekly downloads)
+ *
+ * Writes to .trickle/logs.jsonl as:
+ *   { "kind": "log", "level": "error", "logger": "winston",
+ *     "message": "User not found", "timestamp": 1710516000,
+ *     "meta": { "userId": 123 } }
+ */
+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.patchWinston = patchWinston;
+exports.patchPino = patchPino;
+exports.patchBunyan = patchBunyan;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let logsFile = null;
+let debugMode = false;
+const MAX_LOGS = 1000;
+let logCount = 0;
+const buffer = [];
+function getLogsFile() {
+    if (logsFile)
+        return logsFile;
+    const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch { }
+    logsFile = path.join(dir, 'logs.jsonl');
+    try {
+        fs.writeFileSync(logsFile, '');
+    }
+    catch { }
+    return logsFile;
+}
+function writeLog(record) {
+    if (logCount >= MAX_LOGS)
+        return;
+    logCount++;
+    buffer.push(JSON.stringify(record));
+    if (buffer.length >= 20) {
+        flushLogs();
+    }
+}
+function flushLogs() {
+    if (buffer.length === 0)
+        return;
+    try {
+        fs.appendFileSync(getLogsFile(), buffer.join('\n') + '\n');
+    }
+    catch { }
+    buffer.length = 0;
+}
+// Flush on exit
+process.on('exit', flushLogs);
+/**
+ * Patch winston to capture structured log entries.
+ * Winston uses transports — we add a custom transport that writes to logs.jsonl.
+ */
+function patchWinston(winstonModule, debug) {
+    debugMode = debug;
+    if (winstonModule.__trickle_patched)
+        return;
+    winstonModule.__trickle_patched = true;
+    getLogsFile(); // Initialize file
+    // Create a custom transport
+    const Transport = winstonModule.Transport;
+    if (!Transport)
+        return;
+    class TrickleTransport extends Transport {
+        constructor(opts) {
+            super(opts);
+        }
+        log(info, callback) {
+            const level = info.level || info[Symbol.for('level')] || 'info';
+            const message = info.message || info[Symbol.for('message')] || '';
+            // Extract metadata (everything except level, message, and internal symbols)
+            const meta = {};
+            for (const key of Object.keys(info)) {
+                if (key !== 'level' && key !== 'message' && key !== 'timestamp' && key !== 'splat') {
+                    const val = info[key];
+                    if (val !== undefined && typeof val !== 'symbol' && typeof val !== 'function') {
+                        try {
+                            JSON.stringify(val);
+                            meta[key] = val;
+                        }
+                        catch { }
+                    }
+                }
+            }
+            writeLog({
+                kind: 'log',
+                level: String(level),
+                logger: 'winston',
+                message: String(message).substring(0, 500),
+                timestamp: Date.now(),
+                meta: Object.keys(meta).length > 0 ? meta : undefined,
+            });
+            if (callback)
+                callback();
+        }
+    }
+    // Patch createLogger to auto-add our transport
+    const origCreateLogger = winstonModule.createLogger;
+    if (origCreateLogger && !origCreateLogger.__trickle_patched) {
+        winstonModule.createLogger = function patchedCreateLogger(opts = {}) {
+            const logger = origCreateLogger(opts);
+            try {
+                logger.add(new TrickleTransport({ level: 'silly' }));
+            }
+            catch { }
+            return logger;
+        };
+        winstonModule.createLogger.__trickle_patched = true;
+    }
+    // Also patch the default logger if it exists
+    if (winstonModule.add && winstonModule.transports) {
+        try {
+            winstonModule.add(new TrickleTransport({ level: 'silly' }));
+        }
+        catch { }
+    }
+    if (debug)
+        console.log('[trickle/log] Winston log tracing enabled');
+}
+/**
+ * Patch pino to capture structured log entries.
+ * Pino uses a destination stream — we wrap the pino factory to intercept log calls.
+ */
+function patchPino(pinoModule, debug) {
+    debugMode = debug;
+    const pinoFn = pinoModule.default || pinoModule;
+    if (typeof pinoFn !== 'function' || pinoFn.__trickle_patched)
+        return;
+    getLogsFile(); // Initialize file
+    const PINO_LEVELS = {
+        10: 'trace', 20: 'debug', 30: 'info', 40: 'warn', 50: 'error', 60: 'fatal',
+    };
+    const wrappedPino = function patchedPino(...args) {
+        const logger = pinoFn.apply(this, args);
+        // Wrap the logger's write method to intercept log entries
+        const origWrite = logger[Symbol.for('pino.write')] || logger.write;
+        if (origWrite && typeof origWrite === 'function') {
+            const interceptWrite = function (obj, ...rest) {
+                try {
+                    const parsed = typeof obj === 'string' ? JSON.parse(obj) : obj;
+                    const level = PINO_LEVELS[parsed.level] || String(parsed.level || 'info');
+                    const message = parsed.msg || parsed.message || '';
+                    const meta = {};
+                    for (const key of Object.keys(parsed)) {
+                        if (!['level', 'time', 'pid', 'hostname', 'msg', 'message', 'v'].includes(key)) {
+                            meta[key] = parsed[key];
+                        }
+                    }
+                    writeLog({
+                        kind: 'log',
+                        level,
+                        logger: 'pino',
+                        message: String(message).substring(0, 500),
+                        timestamp: parsed.time || Date.now(),
+                        meta: Object.keys(meta).length > 0 ? meta : undefined,
+                    });
+                }
+                catch { }
+                return origWrite.apply(this, [obj, ...rest]);
+            };
+            if (logger[Symbol.for('pino.write')]) {
+                logger[Symbol.for('pino.write')] = interceptWrite;
+            }
+        }
+        // Also wrap individual level methods as fallback
+        for (const levelName of ['trace', 'debug', 'info', 'warn', 'error', 'fatal']) {
+            const orig = logger[levelName];
+            if (orig && typeof orig === 'function' && !orig.__trickle_patched) {
+                logger[levelName] = function (...logArgs) {
+                    try {
+                        let message = '';
+                        let meta;
+                        if (typeof logArgs[0] === 'object' && logArgs[0] !== null && !(logArgs[0] instanceof Error)) {
+                            meta = {};
+                            for (const [k, v] of Object.entries(logArgs[0])) {
+                                try {
+                                    JSON.stringify(v);
+                                    meta[k] = v;
+                                }
+                                catch { }
+                            }
+                            message = logArgs.length > 1 ? String(logArgs[1]).substring(0, 500) : '';
+                        }
+                        else if (logArgs[0] instanceof Error) {
+                            message = logArgs[0].message.substring(0, 500);
+                            meta = { errorType: logArgs[0].name, stack: logArgs[0].stack?.substring(0, 200) };
+                        }
+                        else {
+                            message = String(logArgs[0] || '').substring(0, 500);
+                        }
+                        writeLog({
+                            kind: 'log',
+                            level: levelName,
+                            logger: 'pino',
+                            message,
+                            timestamp: Date.now(),
+                            meta,
+                        });
+                    }
+                    catch { }
+                    return orig.apply(this, logArgs);
+                };
+                logger[levelName].__trickle_patched = true;
+            }
+        }
+        return logger;
+    };
+    // Copy properties
+    Object.setPrototypeOf(wrappedPino, pinoFn);
+    for (const key of Object.getOwnPropertyNames(pinoFn)) {
+        if (key !== 'length' && key !== 'name' && key !== 'prototype') {
+            try {
+                Object.defineProperty(wrappedPino, key, Object.getOwnPropertyDescriptor(pinoFn, key));
+            }
+            catch { }
+        }
+    }
+    if (pinoModule.default) {
+        pinoModule.default = wrappedPino;
+    }
+    else {
+        // pino exports the function as module.exports — observe-register handles replacement
+    }
+    wrappedPino.__trickle_patched = true;
+    if (debug)
+        console.log('[trickle/log] Pino log tracing enabled');
+    return wrappedPino; // Return for observe-register to use
+}
+/**
+ * Patch bunyan to capture structured log entries.
+ * Bunyan loggers have addStream() — we add a custom stream.
+ */
+function patchBunyan(bunyanModule, debug) {
+    debugMode = debug;
+    if (bunyanModule.__trickle_patched)
+        return;
+    bunyanModule.__trickle_patched = true;
+    getLogsFile(); // Initialize file
+    const BUNYAN_LEVELS = {
+        10: 'trace', 20: 'debug', 30: 'info', 40: 'warn', 50: 'error', 60: 'fatal',
+    };
+    const origCreateLogger = bunyanModule.createLogger;
+    if (!origCreateLogger)
+        return;
+    bunyanModule.createLogger = function patchedCreateLogger(opts) {
+        const logger = origCreateLogger(opts);
+        // Add a trickle stream
+        try {
+            logger.addStream({
+                level: 'trace',
+                type: 'raw',
+                stream: {
+                    write(rec) {
+                        try {
+                            const level = BUNYAN_LEVELS[rec.level] || String(rec.level || 'info');
+                            const message = rec.msg || '';
+                            const meta = {};
+                            for (const key of Object.keys(rec)) {
+                                if (!['v', 'level', 'name', 'hostname', 'pid', 'time', 'msg', 'src'].includes(key)) {
+                                    try {
+                                        JSON.stringify(rec[key]);
+                                        meta[key] = rec[key];
+                                    }
+                                    catch { }
+                                }
+                            }
+                            writeLog({
+                                kind: 'log',
+                                level,
+                                logger: `bunyan:${rec.name || 'default'}`,
+                                message: String(message).substring(0, 500),
+                                timestamp: rec.time ? new Date(rec.time).getTime() : Date.now(),
+                                meta: Object.keys(meta).length > 0 ? meta : undefined,
+                            });
+                        }
+                        catch { }
+                    },
+                },
+            });
+        }
+        catch { }
+        return logger;
+    };
+    if (debug)
+        console.log('[trickle/log] Bunyan log tracing enabled');
+}