trickle-observe 0.2.113 → 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.js

@@ -1726,8 +1726,12 @@ ingestUrl) {
     const catchInsertions = traceVars ? findCatchVars(source) : [];
     // Find function parameter names for tracing
     const funcParamInsertions = traceVars ? findFunctionParams(source, isReactFile) : [];
-    // Find JSX text expressions for tracing (React files only)
-    const jsxExprInsertions = (traceVars && isReactFile) ? findJsxExpressions(source) : [];
+    // Find JSX text expressions for tracing (React files only).
+    // Skip if JSX has already been compiled to _jsxDEV/jsx/jsxs calls (e.g. by Vite's React plugin).
+    // In that case, the `{` characters in the source are plain JS (function bodies, object literals)
+    // and findJsxExpressions would corrupt them by injecting __trickle_tv() calls.
+    const jsxAlreadyCompiled = /\b_?jsxDEV\b|\bjsxs?\s*\(/.test(source);
+    const jsxExprInsertions = (traceVars && isReactFile && !jsxAlreadyCompiled) ? findJsxExpressions(source) : [];
     if (funcInsertions.length === 0 && importInsertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0 && reassignInsertions.length === 0 && forLoopInsertions.length === 0 && catchInsertions.length === 0 && funcParamInsertions.length === 0 && jsxExprInsertions.length === 0 && bodyInsertions.length === 0 && hookInsertions.length === 0 && stateInsertions.length === 0 && conciseBodyInsertions.length === 0)
         return source;
     // Fix line numbers: Vite transforms (TypeScript stripping) may change line numbers.

package/dist-esm/vite-plugin.js

@@ -1713,8 +1713,12 @@ ingestUrl) {
     const catchInsertions = traceVars ? findCatchVars(source) : [];
     // Find function parameter names for tracing
     const funcParamInsertions = traceVars ? findFunctionParams(source, isReactFile) : [];
-    // Find JSX text expressions for tracing (React files only)
-    const jsxExprInsertions = (traceVars && isReactFile) ? findJsxExpressions(source) : [];
+    // Find JSX text expressions for tracing (React files only).
+    // Skip if JSX has already been compiled to _jsxDEV/jsx/jsxs calls (e.g. by Vite's React plugin).
+    // In that case, the `{` characters in the source are plain JS (function bodies, object literals)
+    // and findJsxExpressions would corrupt them by injecting __trickle_tv() calls.
+    const jsxAlreadyCompiled = /\b_?jsxDEV\b|\bjsxs?\s*\(/.test(source);
+    const jsxExprInsertions = (traceVars && isReactFile && !jsxAlreadyCompiled) ? findJsxExpressions(source) : [];
     if (funcInsertions.length === 0 && importInsertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0 && reassignInsertions.length === 0 && forLoopInsertions.length === 0 && catchInsertions.length === 0 && funcParamInsertions.length === 0 && jsxExprInsertions.length === 0 && bodyInsertions.length === 0 && hookInsertions.length === 0 && stateInsertions.length === 0 && conciseBodyInsertions.length === 0)
         return source;
     // Fix line numbers: Vite transforms (TypeScript stripping) may change line numbers.

package/package.json

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

package/src/vite-plugin.ts

@@ -1658,8 +1658,12 @@ export function transformEsmSource(
   // Find function parameter names for tracing
   const funcParamInsertions = traceVars ? findFunctionParams(source, isReactFile) : [];
 
-  // Find JSX text expressions for tracing (React files only)
-  const jsxExprInsertions = (traceVars && isReactFile) ? findJsxExpressions(source) : [];
+  // Find JSX text expressions for tracing (React files only).
+  // Skip if JSX has already been compiled to _jsxDEV/jsx/jsxs calls (e.g. by Vite's React plugin).
+  // In that case, the `{` characters in the source are plain JS (function bodies, object literals)
+  // and findJsxExpressions would corrupt them by injecting __trickle_tv() calls.
+  const jsxAlreadyCompiled = /\b_?jsxDEV\b|\bjsxs?\s*\(/.test(source);
+  const jsxExprInsertions = (traceVars && isReactFile && !jsxAlreadyCompiled) ? findJsxExpressions(source) : [];
 
   if (funcInsertions.length === 0 && importInsertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0 && reassignInsertions.length === 0 && forLoopInsertions.length === 0 && catchInsertions.length === 0 && funcParamInsertions.length === 0 && jsxExprInsertions.length === 0 && bodyInsertions.length === 0 && hookInsertions.length === 0 && stateInsertions.length === 0 && conciseBodyInsertions.length === 0) return source;