trickle-observe 0.2.107 → 0.2.109

package/dist/db-observer.d.ts

@@ -43,6 +43,17 @@ export declare function patchDrizzle(drizzleModule: any, debug: boolean): void;
  * Knex emits 'query' and 'query-response' events on the knex instance.
  */
 export declare function patchKnex(knexModule: any, debug: boolean): void;
+/**
+ * Patch TypeORM to capture queries via its Logger interface.
+ * TypeORM DataSource accepts a `logger` option. We wrap createConnection/DataSource
+ * to inject a custom logger that captures all queries.
+ */
+export declare function patchTypeORM(typeormModule: any, debug: boolean): void;
+/**
+ * Patch Sequelize to capture queries via its logging option.
+ * Sequelize accepts a `logging` function in its constructor options.
+ */
+export declare function patchSequelize(sequelizeModule: any, debug: boolean): void;
 /**
  * Patch mongoose to capture MongoDB operations.
  * Called from observe-register when mongoose is required.

package/dist/db-observer.js

@@ -50,6 +50,8 @@ exports.patchIoredis = patchIoredis;
 exports.patchPrisma = patchPrisma;
 exports.patchDrizzle = patchDrizzle;
 exports.patchKnex = patchKnex;
+exports.patchTypeORM = patchTypeORM;
+exports.patchSequelize = patchSequelize;
 exports.patchMongoose = patchMongoose;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -523,6 +525,154 @@ function patchKnex(knexModule, debug) {
     if (debug)
         console.log('[trickle/db] Knex query tracing enabled');
 }
+/**
+ * Patch TypeORM to capture queries via its Logger interface.
+ * TypeORM DataSource accepts a `logger` option. We wrap createConnection/DataSource
+ * to inject a custom logger that captures all queries.
+ */
+function patchTypeORM(typeormModule, debug) {
+    debugMode = debug;
+    // Patch DataSource constructor (TypeORM 0.3+)
+    const DataSource = typeormModule.DataSource;
+    if (DataSource && !DataSource.__trickle_patched) {
+        const OrigDataSource = DataSource;
+        typeormModule.DataSource = function PatchedDataSource(options) {
+            // Inject custom logger
+            if (!options._trickle_injected) {
+                options._trickle_injected = true;
+                const origLogger = options.logger;
+                options.logger = {
+                    logQuery(query, parameters) {
+                        writeQuery({
+                            kind: 'query',
+                            query: query.substring(0, MAX_QUERY_LENGTH),
+                            params: parameters?.slice(0, 5),
+                            durationMs: 0,
+                            rowCount: 0,
+                            timestamp: Date.now(),
+                        });
+                        if (origLogger && typeof origLogger === 'object' && 'logQuery' in origLogger) {
+                            origLogger.logQuery(query, parameters);
+                        }
+                    },
+                    logQueryError(error, query, parameters) {
+                        writeQuery({
+                            kind: 'query',
+                            query: query.substring(0, MAX_QUERY_LENGTH),
+                            params: parameters?.slice(0, 5),
+                            durationMs: 0,
+                            rowCount: 0,
+                            error: error.substring(0, 200),
+                            timestamp: Date.now(),
+                        });
+                    },
+                    logQuerySlow(time, query, parameters) {
+                        writeQuery({
+                            kind: 'query',
+                            query: query.substring(0, MAX_QUERY_LENGTH),
+                            params: parameters?.slice(0, 5),
+                            durationMs: time,
+                            rowCount: 0,
+                            timestamp: Date.now(),
+                        });
+                    },
+                    logSchemaBuild() { },
+                    logMigration() { },
+                    log() { },
+                };
+            }
+            return new OrigDataSource(options);
+        };
+        // Copy statics
+        Object.setPrototypeOf(typeormModule.DataSource, OrigDataSource);
+        typeormModule.DataSource.prototype = OrigDataSource.prototype;
+        typeormModule.DataSource.__trickle_patched = true;
+    }
+    // Also patch createConnection (TypeORM 0.2)
+    if (typeormModule.createConnection && !typeormModule.createConnection.__trickle_patched) {
+        const origCreate = typeormModule.createConnection;
+        typeormModule.createConnection = function patchedCreateConnection(options) {
+            if (options && typeof options === 'object' && !options.logging) {
+                options.logging = true;
+            }
+            return origCreate(options);
+        };
+        typeormModule.createConnection.__trickle_patched = true;
+    }
+    if (debug)
+        console.log('[trickle/db] TypeORM query tracing enabled');
+}
+/**
+ * Patch Sequelize to capture queries via its logging option.
+ * Sequelize accepts a `logging` function in its constructor options.
+ */
+function patchSequelize(sequelizeModule, debug) {
+    debugMode = debug;
+    const Sequelize = sequelizeModule.Sequelize || sequelizeModule.default || sequelizeModule;
+    if (!Sequelize || typeof Sequelize !== 'function' || Sequelize.__trickle_patched)
+        return;
+    const origConstructor = Sequelize;
+    const patchedSequelize = function (...args) {
+        // Sequelize(uri, options) or Sequelize(database, user, pass, options)
+        let options;
+        if (args.length >= 4) {
+            options = args[3] = args[3] || {};
+        }
+        else if (args.length >= 2 && typeof args[1] === 'object') {
+            options = args[1];
+        }
+        else if (args.length === 1 && typeof args[0] === 'object') {
+            options = args[0];
+        }
+        else {
+            options = {};
+            args.push(options);
+        }
+        // Wrap the logging function
+        const origLogging = options.logging;
+        options.logging = (sql, timing) => {
+            const queryText = typeof sql === 'string' ? sql : String(sql);
+            // Sequelize prepends "Executed (default): " or "Executing (default): " to queries
+            const cleanQuery = queryText.replace(/^Execut(?:ed|ing) \([^)]*\):\s*/, '');
+            const durationMs = typeof timing === 'number' ? timing : 0;
+            writeQuery({
+                kind: 'query',
+                query: cleanQuery.substring(0, MAX_QUERY_LENGTH),
+                durationMs,
+                rowCount: 0,
+                timestamp: Date.now(),
+            });
+            // Call original logger
+            if (typeof origLogging === 'function') {
+                origLogging(sql, timing);
+            }
+        };
+        options.benchmark = true; // Enable timing in log
+        // Call original constructor
+        if (new.target) {
+            return new origConstructor(...args);
+        }
+        return origConstructor.apply(this, args);
+    };
+    // Copy prototype and statics
+    patchedSequelize.prototype = origConstructor.prototype;
+    Object.setPrototypeOf(patchedSequelize, origConstructor);
+    for (const key of Object.getOwnPropertyNames(origConstructor)) {
+        if (key !== 'prototype' && key !== 'length' && key !== 'name') {
+            try {
+                Object.defineProperty(patchedSequelize, key, Object.getOwnPropertyDescriptor(origConstructor, key));
+            }
+            catch { }
+        }
+    }
+    // Replace in module exports
+    if (sequelizeModule.Sequelize) {
+        sequelizeModule.Sequelize = patchedSequelize;
+    }
+    patchedSequelize.__trickle_patched = true;
+    if (debug)
+        console.log('[trickle/db] Sequelize query tracing enabled');
+}
 /**
  * Patch mongoose to capture MongoDB operations.
  * Called from observe-register when mongoose is required.

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');
+}

package/dist/observe-register.js

@@ -1230,6 +1230,51 @@ if (enabled) {
             }
             catch { /* not critical */ }
         }
+        // TypeORM
+        if (request === 'typeorm' && !expressPatched.has('typeorm')) {
+            expressPatched.add('typeorm');
+            try {
+                const { patchTypeORM } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchTypeORM(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // Sequelize
+        if (request === 'sequelize' && !expressPatched.has('sequelize')) {
+            expressPatched.add('sequelize');
+            try {
+                const { patchSequelize } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchSequelize(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // Winston logger
+        if (request === 'winston' && !expressPatched.has('winston')) {
+            expressPatched.add('winston');
+            try {
+                const { patchWinston } = require(path_1.default.join(__dirname, 'log-observer.js'));
+                patchWinston(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // Pino logger
+        if (request === 'pino' && !expressPatched.has('pino')) {
+            expressPatched.add('pino');
+            try {
+                const { patchPino } = require(path_1.default.join(__dirname, 'log-observer.js'));
+                patchPino(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        // Bunyan logger
+        if (request === 'bunyan' && !expressPatched.has('bunyan')) {
+            expressPatched.add('bunyan');
+            try {
+                const { patchBunyan } = require(path_1.default.join(__dirname, 'log-observer.js'));
+                patchBunyan(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
         // Redis (ioredis)
         if (request === 'ioredis' && !expressPatched.has('ioredis')) {
             expressPatched.add('ioredis');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.107",
+  "version": "0.2.109",
   "description": "Runtime type observability for JavaScript applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/db-observer.ts

@@ -533,6 +533,166 @@ export function patchKnex(knexModule: any, debug: boolean): void {
   if (debug) console.log('[trickle/db] Knex query tracing enabled');
 }
 
+/**
+ * Patch TypeORM to capture queries via its Logger interface.
+ * TypeORM DataSource accepts a `logger` option. We wrap createConnection/DataSource
+ * to inject a custom logger that captures all queries.
+ */
+export function patchTypeORM(typeormModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  // Patch DataSource constructor (TypeORM 0.3+)
+  const DataSource = typeormModule.DataSource;
+  if (DataSource && !DataSource.__trickle_patched) {
+    const OrigDataSource = DataSource;
+
+    typeormModule.DataSource = function PatchedDataSource(options: any) {
+      // Inject custom logger
+      if (!options._trickle_injected) {
+        options._trickle_injected = true;
+        const origLogger = options.logger;
+
+        options.logger = {
+          logQuery(query: string, parameters?: any[]) {
+            writeQuery({
+              kind: 'query',
+              query: query.substring(0, MAX_QUERY_LENGTH),
+              params: parameters?.slice(0, 5),
+              durationMs: 0,
+              rowCount: 0,
+              timestamp: Date.now(),
+            });
+            if (origLogger && typeof origLogger === 'object' && 'logQuery' in origLogger) {
+              origLogger.logQuery(query, parameters);
+            }
+          },
+          logQueryError(error: string, query: string, parameters?: any[]) {
+            writeQuery({
+              kind: 'query',
+              query: query.substring(0, MAX_QUERY_LENGTH),
+              params: parameters?.slice(0, 5),
+              durationMs: 0,
+              rowCount: 0,
+              error: error.substring(0, 200),
+              timestamp: Date.now(),
+            });
+          },
+          logQuerySlow(time: number, query: string, parameters?: any[]) {
+            writeQuery({
+              kind: 'query',
+              query: query.substring(0, MAX_QUERY_LENGTH),
+              params: parameters?.slice(0, 5),
+              durationMs: time,
+              rowCount: 0,
+              timestamp: Date.now(),
+            });
+          },
+          logSchemaBuild() {},
+          logMigration() {},
+          log() {},
+        };
+      }
+
+      return new OrigDataSource(options);
+    };
+
+    // Copy statics
+    Object.setPrototypeOf(typeormModule.DataSource, OrigDataSource);
+    typeormModule.DataSource.prototype = OrigDataSource.prototype;
+    typeormModule.DataSource.__trickle_patched = true;
+  }
+
+  // Also patch createConnection (TypeORM 0.2)
+  if (typeormModule.createConnection && !(typeormModule.createConnection as any).__trickle_patched) {
+    const origCreate = typeormModule.createConnection;
+    typeormModule.createConnection = function patchedCreateConnection(options: any) {
+      if (options && typeof options === 'object' && !options.logging) {
+        options.logging = true;
+      }
+      return origCreate(options);
+    };
+    (typeormModule.createConnection as any).__trickle_patched = true;
+  }
+
+  if (debug) console.log('[trickle/db] TypeORM query tracing enabled');
+}
+
+/**
+ * Patch Sequelize to capture queries via its logging option.
+ * Sequelize accepts a `logging` function in its constructor options.
+ */
+export function patchSequelize(sequelizeModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  const Sequelize = sequelizeModule.Sequelize || sequelizeModule.default || sequelizeModule;
+  if (!Sequelize || typeof Sequelize !== 'function' || (Sequelize as any).__trickle_patched) return;
+
+  const origConstructor = Sequelize;
+
+  const patchedSequelize = function (this: any, ...args: any[]) {
+    // Sequelize(uri, options) or Sequelize(database, user, pass, options)
+    let options: any;
+    if (args.length >= 4) {
+      options = args[3] = args[3] || {};
+    } else if (args.length >= 2 && typeof args[1] === 'object') {
+      options = args[1];
+    } else if (args.length === 1 && typeof args[0] === 'object') {
+      options = args[0];
+    } else {
+      options = {};
+      args.push(options);
+    }
+
+    // Wrap the logging function
+    const origLogging = options.logging;
+    options.logging = (sql: string, timing?: any) => {
+      const queryText = typeof sql === 'string' ? sql : String(sql);
+      // Sequelize prepends "Executed (default): " or "Executing (default): " to queries
+      const cleanQuery = queryText.replace(/^Execut(?:ed|ing) \([^)]*\):\s*/, '');
+      const durationMs = typeof timing === 'number' ? timing : 0;
+
+      writeQuery({
+        kind: 'query',
+        query: cleanQuery.substring(0, MAX_QUERY_LENGTH),
+        durationMs,
+        rowCount: 0,
+        timestamp: Date.now(),
+      });
+
+      // Call original logger
+      if (typeof origLogging === 'function') {
+        origLogging(sql, timing);
+      }
+    };
+    options.benchmark = true; // Enable timing in log
+
+    // Call original constructor
+    if (new.target) {
+      return new origConstructor(...args);
+    }
+    return origConstructor.apply(this, args);
+  };
+
+  // Copy prototype and statics
+  patchedSequelize.prototype = origConstructor.prototype;
+  Object.setPrototypeOf(patchedSequelize, origConstructor);
+  for (const key of Object.getOwnPropertyNames(origConstructor)) {
+    if (key !== 'prototype' && key !== 'length' && key !== 'name') {
+      try {
+        Object.defineProperty(patchedSequelize, key, Object.getOwnPropertyDescriptor(origConstructor, key)!);
+      } catch {}
+    }
+  }
+
+  // Replace in module exports
+  if (sequelizeModule.Sequelize) {
+    sequelizeModule.Sequelize = patchedSequelize;
+  }
+  (patchedSequelize as any).__trickle_patched = true;
+
+  if (debug) console.log('[trickle/db] Sequelize query tracing enabled');
+}
+
 /**
  * Patch mongoose to capture MongoDB operations.
  * Called from observe-register when mongoose is required.

package/src/log-observer.ts

@@ -0,0 +1,308 @@
+/**
+ * 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 } }
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface LogRecord {
+  kind: 'log';
+  level: string;
+  logger: string;
+  message: string;
+  timestamp: number;
+  meta?: Record<string, unknown>;
+}
+
+let logsFile: string | null = null;
+let debugMode = false;
+const MAX_LOGS = 1000;
+let logCount = 0;
+const buffer: string[] = [];
+
+function getLogsFile(): string {
+  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: LogRecord): void {
+  if (logCount >= MAX_LOGS) return;
+  logCount++;
+  buffer.push(JSON.stringify(record));
+  if (buffer.length >= 20) {
+    flushLogs();
+  }
+}
+
+function flushLogs(): void {
+  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.
+ */
+export function patchWinston(winstonModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  if ((winstonModule as any).__trickle_patched) return;
+  (winstonModule as any).__trickle_patched = true;
+
+  getLogsFile(); // Initialize file
+
+  // Create a custom transport
+  const Transport = winstonModule.Transport;
+  if (!Transport) return;
+
+  class TrickleTransport extends Transport {
+    constructor(opts?: any) {
+      super(opts);
+    }
+
+    log(info: any, callback: () => void): void {
+      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: Record<string, unknown> = {};
+      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 as any).__trickle_patched) {
+    winstonModule.createLogger = function patchedCreateLogger(opts: any = {}) {
+      const logger = origCreateLogger(opts);
+      try {
+        logger.add(new TrickleTransport({ level: 'silly' }));
+      } catch {}
+      return logger;
+    };
+    (winstonModule.createLogger as any).__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.
+ */
+export function patchPino(pinoModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  const pinoFn = pinoModule.default || pinoModule;
+  if (typeof pinoFn !== 'function' || (pinoFn as any).__trickle_patched) return;
+
+  getLogsFile(); // Initialize file
+
+  const PINO_LEVELS: Record<number, string> = {
+    10: 'trace', 20: 'debug', 30: 'info', 40: 'warn', 50: 'error', 60: 'fatal',
+  };
+
+  const wrappedPino = function patchedPino(this: any, ...args: any[]): any {
+    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 (this: any, obj: any, ...rest: any[]): any {
+        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: Record<string, unknown> = {};
+          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 as any).__trickle_patched) {
+        logger[levelName] = function (this: any, ...logArgs: any[]) {
+          try {
+            let message = '';
+            let meta: Record<string, unknown> | undefined;
+
+            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] as any).__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 as any).__trickle_patched = true;
+
+  if (debug) console.log('[trickle/log] Pino log tracing enabled');
+
+  return wrappedPino as any; // Return for observe-register to use
+}
+
+/**
+ * Patch bunyan to capture structured log entries.
+ * Bunyan loggers have addStream() — we add a custom stream.
+ */
+export function patchBunyan(bunyanModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  if ((bunyanModule as any).__trickle_patched) return;
+  (bunyanModule as any).__trickle_patched = true;
+
+  getLogsFile(); // Initialize file
+
+  const BUNYAN_LEVELS: Record<number, string> = {
+    10: 'trace', 20: 'debug', 30: 'info', 40: 'warn', 50: 'error', 60: 'fatal',
+  };
+
+  const origCreateLogger = bunyanModule.createLogger;
+  if (!origCreateLogger) return;
+
+  bunyanModule.createLogger = function patchedCreateLogger(opts: any) {
+    const logger = origCreateLogger(opts);
+
+    // Add a trickle stream
+    try {
+      logger.addStream({
+        level: 'trace',
+        type: 'raw',
+        stream: {
+          write(rec: any): void {
+            try {
+              const level = BUNYAN_LEVELS[rec.level] || String(rec.level || 'info');
+              const message = rec.msg || '';
+
+              const meta: Record<string, unknown> = {};
+              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');
+}

package/src/observe-register.ts

@@ -1215,6 +1215,51 @@ if (enabled) {
       } catch { /* not critical */ }
     }
 
+    // TypeORM
+    if (request === 'typeorm' && !expressPatched.has('typeorm')) {
+      expressPatched.add('typeorm');
+      try {
+        const { patchTypeORM } = require(path.join(__dirname, 'db-observer.js'));
+        patchTypeORM(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // Sequelize
+    if (request === 'sequelize' && !expressPatched.has('sequelize')) {
+      expressPatched.add('sequelize');
+      try {
+        const { patchSequelize } = require(path.join(__dirname, 'db-observer.js'));
+        patchSequelize(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // Winston logger
+    if (request === 'winston' && !expressPatched.has('winston')) {
+      expressPatched.add('winston');
+      try {
+        const { patchWinston } = require(path.join(__dirname, 'log-observer.js'));
+        patchWinston(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // Pino logger
+    if (request === 'pino' && !expressPatched.has('pino')) {
+      expressPatched.add('pino');
+      try {
+        const { patchPino } = require(path.join(__dirname, 'log-observer.js'));
+        patchPino(exports, debug);
+      } catch { /* not critical */ }
+    }
+
+    // Bunyan logger
+    if (request === 'bunyan' && !expressPatched.has('bunyan')) {
+      expressPatched.add('bunyan');
+      try {
+        const { patchBunyan } = require(path.join(__dirname, 'log-observer.js'));
+        patchBunyan(exports, debug);
+      } catch { /* not critical */ }
+    }
+
     // Redis (ioredis)
     if (request === 'ioredis' && !expressPatched.has('ioredis')) {
       expressPatched.add('ioredis');