trickle-observe 0.2.114 → 0.2.115

package/dist/call-trace.js

@@ -93,6 +93,13 @@ function traceCall(functionName, moduleName) {
 function traceReturn(callId, functionName, moduleName, durationMs, error) {
     const parentId = callStack.length >= 2 ? callStack[callStack.length - 2] : 0;
     const depth = callStack.length - 1;
+    // Get request ID from async context (if inside an Express request)
+    let requestId;
+    try {
+        const { getRequestId } = require('./request-context');
+        requestId = getRequestId();
+    }
+    catch { }
     writeEvent({
         kind: 'call',
         function: functionName,
@@ -103,6 +110,7 @@ function traceReturn(callId, functionName, moduleName, durationMs, error) {
         timestamp: Date.now(),
         durationMs: Math.round(durationMs * 100) / 100,
         ...(error ? { error } : {}),
+        ...(requestId ? { requestId } : {}),
     });
     // Pop from stack
     if (callStack[callStack.length - 1] === callId) {

package/dist/db-observer.js

@@ -80,6 +80,14 @@ function writeQuery(record) {
     if (queryCount >= MAX_QUERIES)
         return;
     queryCount++;
+    // Add request ID from async context
+    try {
+        const { getRequestId } = require('./request-context');
+        const reqId = getRequestId();
+        if (reqId)
+            record.requestId = reqId;
+    }
+    catch { }
     try {
         fs.appendFileSync(getQueriesFile(), JSON.stringify(record) + '\n');
     }

package/dist/express.js

@@ -293,63 +293,77 @@ function trickleMiddleware(userOpts) {
             next();
             return;
         }
-        if (debug) {
-            console.log(`[trickle/middleware] Intercepting ${req.method} ${req.originalUrl || req.url}`);
+        // Wrap in request context for per-request correlation
+        try {
+            const { withRequestContext } = require('./request-context');
+            withRequestContext(req, () => {
+                _handleRequest(req, res, next, opts, debug);
+            });
+            return;
         }
-        let captured = false;
-        // We derive the route name lazily once the response is being sent,
-        // because req.route is only populated after the handler matches.
-        function getRouteName() {
-            try {
-                if (req.route && req.route.path) {
-                    return `${req.method} ${req.baseUrl || ''}${req.route.path}`;
-                }
-            }
-            catch {
-                // ignore
-            }
-            return `${req.method || 'UNKNOWN'} ${req.originalUrl || req.url || '/'}`;
+        catch {
+            // Fall through to non-context version
         }
-        const input = extractRequestInput(req);
-        // Intercept res.json()
-        const originalJson = res.json;
-        if (typeof originalJson === 'function') {
-            res.json = function (data) {
-                if (!captured) {
-                    captured = true;
-                    const routeName = getRouteName();
-                    if (debug) {
-                        console.log(`[trickle/middleware] Captured res.json for ${routeName}`);
-                    }
-                    // Re-extract input here because body parsers may have run since middleware was entered
-                    const latestInput = extractRequestInput(req);
-                    emitExpressPayload(routeName, opts.environment, opts.maxDepth, latestInput, data);
-                }
-                res.json = originalJson;
-                return originalJson.call(res, data);
-            };
+        _handleRequest(req, res, next, opts, debug);
+    };
+}
+function _handleRequest(req, res, next, opts, debug) {
+    if (debug) {
+        console.log(`[trickle/middleware] Intercepting ${req.method} ${req.originalUrl || req.url}`);
+    }
+    let captured = false;
+    // We derive the route name lazily once the response is being sent,
+    // because req.route is only populated after the handler matches.
+    function getRouteName() {
+        try {
+            if (req.route && req.route.path) {
+                return `${req.method} ${req.baseUrl || ''}${req.route.path}`;
+            }
         }
-        else if (debug) {
-            console.log(`[trickle/middleware] res.json is not a function: ${typeof originalJson}`);
+        catch {
+            // ignore
         }
-        // Intercept res.send()
-        const originalSend = res.send;
-        if (typeof originalSend === 'function') {
-            res.send = function (data) {
-                if (!captured) {
-                    captured = true;
-                    const routeName = getRouteName();
-                    if (debug) {
-                        console.log(`[trickle/middleware] Captured res.send for ${routeName}`);
-                    }
-                    const latestInput = extractRequestInput(req);
-                    const output = typeof data === 'string' ? { __html: true } : data;
-                    emitExpressPayload(routeName, opts.environment, opts.maxDepth, latestInput, output);
+        return `${req.method || 'UNKNOWN'} ${req.originalUrl || req.url || '/'}`;
+    }
+    const input = extractRequestInput(req);
+    // Intercept res.json()
+    const originalJson = res.json;
+    if (typeof originalJson === 'function') {
+        res.json = function (data) {
+            if (!captured) {
+                captured = true;
+                const routeName = getRouteName();
+                if (debug) {
+                    console.log(`[trickle/middleware] Captured res.json for ${routeName}`);
                 }
-                res.send = originalSend;
-                return originalSend.call(res, data);
-            };
-        }
-        next();
-    };
+                // Re-extract input here because body parsers may have run since middleware was entered
+                const latestInput = extractRequestInput(req);
+                emitExpressPayload(routeName, opts.environment, opts.maxDepth, latestInput, data);
+            }
+            res.json = originalJson;
+            return originalJson.call(res, data);
+        };
+    }
+    else if (debug) {
+        console.log(`[trickle/middleware] res.json is not a function: ${typeof originalJson}`);
+    }
+    // Intercept res.send()
+    const originalSend = res.send;
+    if (typeof originalSend === 'function') {
+        res.send = function (data) {
+            if (!captured) {
+                captured = true;
+                const routeName = getRouteName();
+                if (debug) {
+                    console.log(`[trickle/middleware] Captured res.send for ${routeName}`);
+                }
+                const latestInput = extractRequestInput(req);
+                const output = typeof data === 'string' ? { __html: true } : data;
+                emitExpressPayload(routeName, opts.environment, opts.maxDepth, latestInput, output);
+            }
+            res.send = originalSend;
+            return originalSend.call(res, data);
+        };
+    }
+    next();
 }

package/dist/request-context.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Request context — propagates a request ID through async call chains.
+ *
+ * Uses Node.js AsyncLocalStorage so that all functions, queries, and logs
+ * within a single HTTP request share the same requestId, enabling
+ * per-request tracing (like Jaeger but with trickle's richer data).
+ *
+ * Usage:
+ *   import { withRequestContext, getRequestId } from './request-context';
+ *   // In Express middleware:
+ *   app.use((req, res, next) => withRequestContext(req, next));
+ *   // Anywhere in the call chain:
+ *   const id = getRequestId(); // returns the current request's ID
+ */
+export interface RequestContext {
+    requestId: string;
+    method?: string;
+    path?: string;
+    startTime: number;
+}
+/**
+ * Run a callback within a request context.
+ */
+export declare function withRequestContext(req: any, callback: () => void): void;
+/**
+ * Get the current request ID (if inside a request context).
+ */
+export declare function getRequestId(): string | undefined;
+/**
+ * Get the full request context.
+ */
+export declare function getRequestContext(): RequestContext | undefined;

package/dist/request-context.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Request context — propagates a request ID through async call chains.
+ *
+ * Uses Node.js AsyncLocalStorage so that all functions, queries, and logs
+ * within a single HTTP request share the same requestId, enabling
+ * per-request tracing (like Jaeger but with trickle's richer data).
+ *
+ * Usage:
+ *   import { withRequestContext, getRequestId } from './request-context';
+ *   // In Express middleware:
+ *   app.use((req, res, next) => withRequestContext(req, next));
+ *   // Anywhere in the call chain:
+ *   const id = getRequestId(); // returns the current request's ID
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRequestContext = withRequestContext;
+exports.getRequestId = getRequestId;
+exports.getRequestContext = getRequestContext;
+let als = null;
+let counter = 0;
+try {
+    const { AsyncLocalStorage } = require('async_hooks');
+    als = new AsyncLocalStorage();
+}
+catch {
+    // AsyncLocalStorage not available (older Node versions)
+}
+/**
+ * Run a callback within a request context.
+ */
+function withRequestContext(req, callback) {
+    if (!als) {
+        callback();
+        return;
+    }
+    const ctx = {
+        requestId: `req-${++counter}-${Date.now().toString(36)}`,
+        method: req?.method,
+        path: req?.path || req?.url,
+        startTime: Date.now(),
+    };
+    als.run(ctx, callback);
+}
+/**
+ * Get the current request ID (if inside a request context).
+ */
+function getRequestId() {
+    if (!als)
+        return undefined;
+    const ctx = als.getStore();
+    return ctx?.requestId;
+}
+/**
+ * Get the full request context.
+ */
+function getRequestContext() {
+    if (!als)
+        return undefined;
+    return als.getStore();
+}

package/dist/vite-plugin.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vite-plugin.test.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Unit tests for the Vite plugin transform (React component tracking).
+ *
+ * Run with: node --experimental-strip-types --test src/vite-plugin.test.ts
+ * Or after build: node --test dist/vite-plugin.test.js
+ */
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const vite_plugin_js_1 = require("../dist/vite-plugin.js");
+// Helper: transform code as if it came from a .tsx file
+function transformTsx(code) {
+    const plugin = (0, vite_plugin_js_1.tricklePlugin)({ debug: false, traceVars: false });
+    const result = plugin.transform(code, '/test/App.tsx');
+    return result ? result.code : null;
+}
+function transformTs(code) {
+    const plugin = (0, vite_plugin_js_1.tricklePlugin)({ debug: false, traceVars: false });
+    const result = plugin.transform(code, '/test/util.ts');
+    return result ? result.code : null;
+}
+// ── React file detection ─────────────────────────────────────────────────────
+(0, node_test_1.describe)('React file detection', () => {
+    (0, node_test_1.it)('tracks uppercase components in .tsx files', () => {
+        const code = `function UserCard(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('__trickle_rc'), 'should inject render tracker');
+    });
+    (0, node_test_1.it)('does not inject render tracker for .ts files', () => {
+        const code = `function UserCard(props) { return null; }`;
+        const out = transformTs(code);
+        // May still transform for function wrapping, but not for render tracking
+        if (out) {
+            strict_1.default.ok(!out.includes('__trickle_rc'), 'should NOT inject render tracker in .ts files');
+        }
+    });
+    (0, node_test_1.it)('does not track lowercase functions as components', () => {
+        const code = `function helper(x) { return x + 1; }`;
+        const out = transformTsx(code);
+        if (out) {
+            strict_1.default.ok(!out.includes('__trickle_rc'), 'lowercase function should not be tracked');
+        }
+    });
+});
+// ── Props capture: function declarations ─────────────────────────────────────
+(0, node_test_1.describe)('Props capture — function declarations', () => {
+    (0, node_test_1.it)('uses arguments[0] for simple param: function Component(props)', () => {
+        const code = `function MyComponent(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('arguments[0]'), 'should pass arguments[0] as props');
+    });
+    (0, node_test_1.it)('uses arguments[0] for destructured param: function Component({ name })', () => {
+        const code = `function UserCard({ name, age }) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('arguments[0]'), 'should pass arguments[0] for destructured params');
+    });
+    (0, node_test_1.it)('injects __trickle_rc call at start of function body', () => {
+        const code = `function MyComponent(props) {\n  const x = 1;\n  return null;\n}`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        // __trickle_rc should appear before body statements
+        const rcIdx = out.indexOf('__trickle_rc');
+        const bodyIdx = out.indexOf('const x = 1');
+        strict_1.default.ok(rcIdx !== -1, '__trickle_rc should be present');
+        strict_1.default.ok(bodyIdx !== -1, 'body code should be present');
+        strict_1.default.ok(rcIdx < bodyIdx, '__trickle_rc should come before body statements');
+    });
+    (0, node_test_1.it)('includes correct component name and line in __trickle_rc call', () => {
+        const code = `function UserCard(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('"UserCard"'), 'should include component name');
+        strict_1.default.ok(out.includes('__trickle_rc("UserCard"'), 'should call with component name');
+    });
+});
+// ── Props capture: arrow function components ──────────────────────────────────
+(0, node_test_1.describe)('Props capture — arrow function components', () => {
+    (0, node_test_1.it)('uses single param name for simple arrow: const C = (props) => {}', () => {
+        const code = `const Dashboard = (props) => { return null; };`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('__trickle_rc'), 'should inject render tracker');
+        // props should be the param variable, not arguments[0]
+        strict_1.default.ok(out.includes('__trickle_rc("Dashboard"'), 'should use component name');
+        // should NOT use arguments[0] for arrow functions
+        const rcCall = out.match(/__trickle_rc\("Dashboard",[^)]+\)/);
+        strict_1.default.ok(rcCall, 'should have __trickle_rc call');
+        strict_1.default.ok(!rcCall[0].includes('arguments[0]'), 'arrow functions should not use arguments[0]');
+    });
+    (0, node_test_1.it)('reconstructs object for destructured arrow: const C = ({ a, b }) => {}', () => {
+        const code = `const Counter = ({ count, label }) => { return null; };`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('__trickle_rc'), 'should inject render tracker');
+        // Should reconstruct { count, label }
+        const rcCall = out.match(/__trickle_rc\("Counter",[^,]+,([^)]+)\)/);
+        if (rcCall) {
+            strict_1.default.ok(rcCall[1].includes('count') && rcCall[1].includes('label'), 'should reconstruct props object from destructured fields');
+        }
+    });
+    (0, node_test_1.it)('passes undefined for no-param arrow: const C = () => {}', () => {
+        const code = `const NoProps = () => { return null; };`;
+        const out = transformTsx(code);
+        if (out && out.includes('__trickle_rc')) {
+            strict_1.default.ok(out.includes('undefined'), 'should pass undefined for no-param component');
+        }
+    });
+});
+// ── render count tracking ─────────────────────────────────────────────────────
+(0, node_test_1.describe)('Render count tracking', () => {
+    (0, node_test_1.it)('includes react_render kind in emitted record code', () => {
+        const code = `function Card(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes("'react_render'"), 'emitted record should have kind react_render');
+    });
+    (0, node_test_1.it)('includes props data in emitted record', () => {
+        const code = `function Card(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('rec.props'), 'should capture props onto the record');
+        strict_1.default.ok(out.includes('propKeys'), 'should include propKeys');
+    });
+    (0, node_test_1.it)('tracks multiple components in one file', () => {
+        const code = [
+            `function Header(props) { return null; }`,
+            `function Footer(props) { return null; }`,
+            `function helper(x) { return x; }`,
+        ].join('\n');
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('"Header"'), 'should track Header');
+        strict_1.default.ok(out.includes('"Footer"'), 'should track Footer');
+        // helper should not be tracked as a component
+        const rcCalls = out.match(/__trickle_rc\("helper"/g);
+        strict_1.default.ok(!rcCalls, 'lowercase helper should not be tracked');
+    });
+});
+// ── findFunctionBodyBrace — destructured params don't confuse brace finding ───
+(0, node_test_1.describe)('Correct function body brace detection', () => {
+    (0, node_test_1.it)('finds body brace even with destructured object params', () => {
+        const code = `function Form({ onSubmit, title }) {\n  const x = 1;\n  return null;\n}`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        // __trickle_rc should be INSIDE the function body (before 'const x = 1')
+        const rcIdx = out.indexOf('__trickle_rc');
+        const bodyIdx = out.indexOf('const x = 1');
+        strict_1.default.ok(rcIdx < bodyIdx, 'render tracker must be inside the function body, before first statement');
+        // The wrap insertion should be AFTER the closing brace of the function
+        const wrapIdx = out.indexOf('__trickle_wrap');
+        strict_1.default.ok(wrapIdx > bodyIdx, 'function wrap should be after the function body');
+    });
+});

package/package.json

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

package/src/call-trace.ts

@@ -21,6 +21,7 @@ interface CallEvent {
   timestamp: number;
   durationMs: number;
   error?: string;
+  requestId?: string;
 }
 
 let traceFile: string | null = null;
@@ -71,6 +72,13 @@ export function traceReturn(
   const parentId = callStack.length >= 2 ? callStack[callStack.length - 2] : 0;
   const depth = callStack.length - 1;
 
+  // Get request ID from async context (if inside an Express request)
+  let requestId: string | undefined;
+  try {
+    const { getRequestId } = require('./request-context');
+    requestId = getRequestId();
+  } catch {}
+
   writeEvent({
     kind: 'call',
     function: functionName,
@@ -81,6 +89,7 @@ export function traceReturn(
     timestamp: Date.now(),
     durationMs: Math.round(durationMs * 100) / 100,
     ...(error ? { error } : {}),
+    ...(requestId ? { requestId } : {}),
   });
 
   // Pop from stack

package/src/db-observer.ts

@@ -21,6 +21,7 @@ interface QueryRecord {
   columns?: string[];
   error?: string;
   timestamp: number;
+  requestId?: string;
 }
 
 let queriesFile: string | null = null;
@@ -42,6 +43,12 @@ function getQueriesFile(): string {
 function writeQuery(record: QueryRecord): void {
   if (queryCount >= MAX_QUERIES) return;
   queryCount++;
+  // Add request ID from async context
+  try {
+    const { getRequestId } = require('./request-context');
+    const reqId = getRequestId();
+    if (reqId) record.requestId = reqId;
+  } catch {}
   try {
     fs.appendFileSync(getQueriesFile(), JSON.stringify(record) + '\n');
   } catch {}

package/src/express.ts

@@ -334,6 +334,22 @@ export function trickleMiddleware(
       return;
     }
 
+    // Wrap in request context for per-request correlation
+    try {
+      const { withRequestContext } = require('./request-context');
+      withRequestContext(req, () => {
+        _handleRequest(req, res, next, opts, debug);
+      });
+      return;
+    } catch {
+      // Fall through to non-context version
+    }
+
+    _handleRequest(req, res, next, opts, debug);
+  };
+}
+
+function _handleRequest(req: any, res: any, next: any, opts: any, debug: boolean): void {
     if (debug) {
       console.log(`[trickle/middleware] Intercepting ${req.method} ${req.originalUrl || req.url}`);
     }
@@ -396,5 +412,4 @@ export function trickleMiddleware(
     }
 
     next();
-  };
 }

package/src/request-context.ts

@@ -0,0 +1,64 @@
+/**
+ * Request context — propagates a request ID through async call chains.
+ *
+ * Uses Node.js AsyncLocalStorage so that all functions, queries, and logs
+ * within a single HTTP request share the same requestId, enabling
+ * per-request tracing (like Jaeger but with trickle's richer data).
+ *
+ * Usage:
+ *   import { withRequestContext, getRequestId } from './request-context';
+ *   // In Express middleware:
+ *   app.use((req, res, next) => withRequestContext(req, next));
+ *   // Anywhere in the call chain:
+ *   const id = getRequestId(); // returns the current request's ID
+ */
+
+let als: any = null;
+let counter = 0;
+
+try {
+  const { AsyncLocalStorage } = require('async_hooks');
+  als = new AsyncLocalStorage();
+} catch {
+  // AsyncLocalStorage not available (older Node versions)
+}
+
+export interface RequestContext {
+  requestId: string;
+  method?: string;
+  path?: string;
+  startTime: number;
+}
+
+/**
+ * Run a callback within a request context.
+ */
+export function withRequestContext(req: any, callback: () => void): void {
+  if (!als) { callback(); return; }
+
+  const ctx: RequestContext = {
+    requestId: `req-${++counter}-${Date.now().toString(36)}`,
+    method: req?.method,
+    path: req?.path || req?.url,
+    startTime: Date.now(),
+  };
+
+  als.run(ctx, callback);
+}
+
+/**
+ * Get the current request ID (if inside a request context).
+ */
+export function getRequestId(): string | undefined {
+  if (!als) return undefined;
+  const ctx = als.getStore() as RequestContext | undefined;
+  return ctx?.requestId;
+}
+
+/**
+ * Get the full request context.
+ */
+export function getRequestContext(): RequestContext | undefined {
+  if (!als) return undefined;
+  return als.getStore() as RequestContext | undefined;
+}