trickle-observe 0.2.115 → 0.2.117

package/dist/call-trace.js

@@ -51,7 +51,7 @@ let traceFile = null;
 let callCounter = 0;
 let currentCallId = 0; // 0 = top level
 const callStack = [0];
-const MAX_TRACE_EVENTS = 500;
+const MAX_TRACE_EVENTS = 1000;
 let eventCount = 0;
 function getTraceFile() {
     if (traceFile)
@@ -62,12 +62,17 @@ function getTraceFile() {
     }
     catch { }
     traceFile = path.join(dir, 'calltrace.jsonl');
+    // Only create the file if it doesn't already exist — another module instance
+    // (e.g. the observe hook) may have already initialised it.
     try {
-        fs.writeFileSync(traceFile, '');
+        fs.writeFileSync(traceFile, '', { flag: 'wx' });
+    }
+    catch {
+        // File already exists — that's fine
     }
-    catch { }
     return traceFile;
 }
+let _initialized = false;
 function writeEvent(event) {
     if (eventCount >= MAX_TRACE_EVENTS)
         return;
@@ -118,6 +123,18 @@ function traceReturn(callId, functionName, moduleName, durationMs, error) {
     }
 }
 function initCallTrace() {
-    // Ensure trace file is initialized
-    getTraceFile();
+    if (_initialized)
+        return;
+    _initialized = true;
+    // Truncate the file on explicit init (only the observe hook calls this)
+    const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch { }
+    traceFile = path.join(dir, 'calltrace.jsonl');
+    try {
+        fs.writeFileSync(traceFile, '');
+    }
+    catch { }
 }

package/dist/express.js

@@ -1,12 +1,49 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.instrumentExpress = instrumentExpress;
 exports.trickleMiddleware = trickleMiddleware;
+const fs = __importStar(require("fs"));
+const pathMod = __importStar(require("path"));
 const type_inference_1 = require("./type-inference");
 const type_hash_1 = require("./type-hash");
 const cache_1 = require("./cache");
 const transport_1 = require("./transport");
 const env_detect_1 = require("./env-detect");
+const request_context_1 = require("./request-context");
+const call_trace_1 = require("./call-trace");
 const expressCache = new cache_1.TypeCache();
 /**
  * Extract the interesting parts of an Express request as a plain object
@@ -91,10 +128,55 @@ function sanitizeSample(value, depth = 3) {
     }
     return String(value);
 }
+/**
+ * Write an error record to .trickle/errors.jsonl so that `trickle monitor`
+ * and `trickle heal` can detect runtime errors from Express handlers.
+ */
+function writeErrorToFile(error, input, routeName) {
+    try {
+        const err = error instanceof Error ? error : new Error(String(error));
+        const isLambda = !!process.env.AWS_LAMBDA_FUNCTION_NAME;
+        const defaultDir = isLambda ? '/tmp/.trickle' : pathMod.join(process.cwd(), '.trickle');
+        const dir = process.env.TRICKLE_LOCAL_DIR || defaultDir;
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        catch { }
+        // Extract file and line from stack trace
+        const stackLines = (err.stack || '').split('\n');
+        let errorFile;
+        let errorLine;
+        for (const sl of stackLines.slice(1)) {
+            const m = sl.match(/\((.+):(\d+):\d+\)/) || sl.match(/at (.+):(\d+):\d+/);
+            if (m && !m[1].includes('node_modules') && !m[1].includes('node:') && !m[1].includes('trickle-observe')) {
+                errorFile = m[1];
+                errorLine = parseInt(m[2]);
+                break;
+            }
+        }
+        const record = {
+            kind: 'error',
+            error: err.message,
+            type: err.constructor?.name || 'Error',
+            message: err.message,
+            file: errorFile,
+            line: errorLine,
+            stack: stackLines.slice(0, 6).join('\n'),
+            route: routeName,
+            request: input,
+            timestamp: new Date().toISOString(),
+        };
+        const errorsFile = pathMod.join(dir, 'errors.jsonl');
+        fs.appendFileSync(errorsFile, JSON.stringify(record) + '\n');
+    }
+    catch {
+        // Never crash the user's app
+    }
+}
 /**
  * Emit a type payload for a single Express route invocation.
  */
-function emitExpressPayload(functionName, environment, maxDepth, input, output, error) {
+function emitExpressPayload(functionName, environment, maxDepth, input, output, error, durationMs) {
     try {
         const functionKey = `express::${functionName}`;
         const argsType = (0, type_inference_1.inferType)(input, maxDepth);
@@ -118,6 +200,9 @@ function emitExpressPayload(functionName, environment, maxDepth, input, output,
             sampleInput: sanitizeSample(input),
             sampleOutput: error ? undefined : sanitizeSample(output),
         };
+        if (durationMs !== undefined) {
+            payload.durationMs = Math.round(durationMs * 100) / 100;
+        }
         if (error) {
             const err = error instanceof Error ? error : new Error(String(error));
             payload.error = {
@@ -126,6 +211,8 @@ function emitExpressPayload(functionName, environment, maxDepth, input, output,
                 stackTrace: err.stack,
                 argsSnapshot: sanitizeSample(input),
             };
+            // Also write to errors.jsonl for monitor/heal detection
+            writeErrorToFile(error, input, functionName);
         }
         (0, transport_1.enqueue)(payload);
     }
@@ -143,15 +230,28 @@ function wrapExpressHandler(handler, routeName, opts) {
         if (opts.sampleRate < 1 && Math.random() > opts.sampleRate) {
             return handler.call(this, req, res, next);
         }
+        const self = this;
+        // Wrap entire handler execution in request context so downstream calls get a request ID
+        let returnValue;
+        (0, request_context_1.withRequestContext)(req, () => {
+            returnValue = _executeHandler(self, handler, req, res, next, routeName, opts);
+        });
+        return returnValue;
+    };
+    function _executeHandler(self, handler, req, res, next, routeName, opts) {
         const input = extractRequestInput(req);
         let captured = false;
+        const startTime = performance.now();
+        const callId = (0, call_trace_1.traceCall)(routeName, 'express');
         // Intercept res.json()
         const originalJson = res.json;
         if (typeof originalJson === 'function') {
             res.json = function (data) {
                 if (!captured) {
                     captured = true;
-                    emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, data);
+                    const durationMs = performance.now() - startTime;
+                    (0, call_trace_1.traceReturn)(callId, routeName, 'express', durationMs);
+                    emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, data, undefined, durationMs);
                 }
                 res.json = originalJson; // restore
                 return originalJson.call(res, data);
@@ -163,9 +263,11 @@ function wrapExpressHandler(handler, routeName, opts) {
             res.send = function (data) {
                 if (!captured) {
                     captured = true;
+                    const durationMs = performance.now() - startTime;
+                    (0, call_trace_1.traceReturn)(callId, routeName, 'express', durationMs);
                     // Only capture non-string data as typed output; strings are usually HTML
                     const output = typeof data === 'string' ? { __html: true } : data;
-                    emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, output);
+                    emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, output, undefined, durationMs);
                 }
                 res.send = originalSend; // restore
                 return originalSend.call(res, data);
@@ -175,20 +277,24 @@ function wrapExpressHandler(handler, routeName, opts) {
         const wrappedNext = function (err) {
             if (err && !captured) {
                 captured = true;
-                emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err);
+                const durationMs = performance.now() - startTime;
+                (0, call_trace_1.traceReturn)(callId, routeName, 'express', durationMs, (err instanceof Error ? err : new Error(String(err))).message);
+                emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err, durationMs);
             }
             if (typeof next === 'function') {
                 return next(err);
             }
         };
         try {
-            const result = handler.call(this, req, res, wrappedNext);
+            const result = handler.call(self, req, res, wrappedNext);
             // Handle async handlers that return a promise
             if (result && typeof result === 'object' && typeof result.then === 'function') {
                 return result.catch((err) => {
                     if (!captured) {
                         captured = true;
-                        emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err);
+                        const durationMs = performance.now() - startTime;
+                        (0, call_trace_1.traceReturn)(callId, routeName, 'express', durationMs, (err instanceof Error ? err : new Error(String(err))).message);
+                        emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err, durationMs);
                     }
                     // Re-throw so Express error handling picks it up
                     throw err;
@@ -199,11 +305,13 @@ function wrapExpressHandler(handler, routeName, opts) {
         catch (err) {
             if (!captured) {
                 captured = true;
-                emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err);
+                const durationMs = performance.now() - startTime;
+                (0, call_trace_1.traceReturn)(callId, routeName, 'express', durationMs, (err instanceof Error ? err : new Error(String(err))).message);
+                emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err, durationMs);
             }
             throw err;
         }
-    };
+    }
     // Preserve function metadata
     Object.defineProperty(wrapped, 'name', { value: handler.name || routeName, configurable: true });
     Object.defineProperty(wrapped, 'length', { value: handler.length, configurable: true });
@@ -294,17 +402,9 @@ function trickleMiddleware(userOpts) {
             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);
+        (0, request_context_1.withRequestContext)(req, () => {
+            _handleRequest(req, res, next, opts, debug);
+        });
     };
 }
 function _handleRequest(req, res, next, opts, debug) {
@@ -312,6 +412,9 @@ function _handleRequest(req, res, next, opts, debug) {
         console.log(`[trickle/middleware] Intercepting ${req.method} ${req.originalUrl || req.url}`);
     }
     let captured = false;
+    const startTime = performance.now();
+    const prelimRouteName = `${req.method || 'UNKNOWN'} ${req.originalUrl || req.url || '/'}`;
+    const callId = (0, call_trace_1.traceCall)(prelimRouteName, 'express');
     // We derive the route name lazily once the response is being sent,
     // because req.route is only populated after the handler matches.
     function getRouteName() {
@@ -323,7 +426,7 @@ function _handleRequest(req, res, next, opts, debug) {
         catch {
             // ignore
         }
-        return `${req.method || 'UNKNOWN'} ${req.originalUrl || req.url || '/'}`;
+        return prelimRouteName;
     }
     const input = extractRequestInput(req);
     // Intercept res.json()
@@ -333,12 +436,14 @@ function _handleRequest(req, res, next, opts, debug) {
             if (!captured) {
                 captured = true;
                 const routeName = getRouteName();
+                const durationMs = performance.now() - startTime;
+                (0, call_trace_1.traceReturn)(callId, routeName, 'express', durationMs);
                 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);
+                emitExpressPayload(routeName, opts.environment, opts.maxDepth, latestInput, data, undefined, durationMs);
             }
             res.json = originalJson;
             return originalJson.call(res, data);
@@ -354,12 +459,14 @@ function _handleRequest(req, res, next, opts, debug) {
             if (!captured) {
                 captured = true;
                 const routeName = getRouteName();
+                const durationMs = performance.now() - startTime;
+                (0, call_trace_1.traceReturn)(callId, routeName, 'express', durationMs);
                 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);
+                emitExpressPayload(routeName, opts.environment, opts.maxDepth, latestInput, output, undefined, durationMs);
             }
             res.send = originalSend;
             return originalSend.call(res, data);

package/package.json

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

package/src/call-trace.ts

@@ -28,7 +28,7 @@ let traceFile: string | null = null;
 let callCounter = 0;
 let currentCallId = 0; // 0 = top level
 const callStack: number[] = [0];
-const MAX_TRACE_EVENTS = 500;
+const MAX_TRACE_EVENTS = 1000;
 let eventCount = 0;
 
 function getTraceFile(): string {
@@ -36,10 +36,18 @@ function getTraceFile(): string {
   const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
   try { fs.mkdirSync(dir, { recursive: true }); } catch {}
   traceFile = path.join(dir, 'calltrace.jsonl');
-  try { fs.writeFileSync(traceFile, ''); } catch {}
+  // Only create the file if it doesn't already exist — another module instance
+  // (e.g. the observe hook) may have already initialised it.
+  try {
+    fs.writeFileSync(traceFile, '', { flag: 'wx' });
+  } catch {
+    // File already exists — that's fine
+  }
   return traceFile;
 }
 
+let _initialized = false;
+
 function writeEvent(event: CallEvent): void {
   if (eventCount >= MAX_TRACE_EVENTS) return;
   eventCount++;
@@ -99,6 +107,11 @@ export function traceReturn(
 }
 
 export function initCallTrace(): void {
-  // Ensure trace file is initialized
-  getTraceFile();
+  if (_initialized) return;
+  _initialized = true;
+  // Truncate the file on explicit init (only the observe hook calls this)
+  const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+  traceFile = path.join(dir, 'calltrace.jsonl');
+  try { fs.writeFileSync(traceFile, ''); } catch {}
 }

package/src/express.ts

@@ -1,9 +1,13 @@
+import * as fs from 'fs';
+import * as pathMod from 'path';
 import { TypeNode, IngestPayload, WrapOptions } from './types';
 import { inferType } from './type-inference';
 import { hashType } from './type-hash';
 import { TypeCache } from './cache';
 import { enqueue } from './transport';
 import { detectEnvironment } from './env-detect';
+import { withRequestContext } from './request-context';
+import { traceCall, traceReturn } from './call-trace';
 
 const expressCache = new TypeCache();
 
@@ -94,6 +98,51 @@ function sanitizeSample(value: unknown, depth: number = 3): unknown {
   return String(value);
 }
 
+/**
+ * Write an error record to .trickle/errors.jsonl so that `trickle monitor`
+ * and `trickle heal` can detect runtime errors from Express handlers.
+ */
+function writeErrorToFile(error: unknown, input: Record<string, unknown>, routeName: string): void {
+  try {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const isLambda = !!process.env.AWS_LAMBDA_FUNCTION_NAME;
+    const defaultDir = isLambda ? '/tmp/.trickle' : pathMod.join(process.cwd(), '.trickle');
+    const dir = process.env.TRICKLE_LOCAL_DIR || defaultDir;
+    try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+
+    // Extract file and line from stack trace
+    const stackLines = (err.stack || '').split('\n');
+    let errorFile: string | undefined;
+    let errorLine: number | undefined;
+    for (const sl of stackLines.slice(1)) {
+      const m = sl.match(/\((.+):(\d+):\d+\)/) || sl.match(/at (.+):(\d+):\d+/);
+      if (m && !m[1].includes('node_modules') && !m[1].includes('node:') && !m[1].includes('trickle-observe')) {
+        errorFile = m[1];
+        errorLine = parseInt(m[2]);
+        break;
+      }
+    }
+
+    const record = {
+      kind: 'error',
+      error: err.message,
+      type: err.constructor?.name || 'Error',
+      message: err.message,
+      file: errorFile,
+      line: errorLine,
+      stack: stackLines.slice(0, 6).join('\n'),
+      route: routeName,
+      request: input,
+      timestamp: new Date().toISOString(),
+    };
+
+    const errorsFile = pathMod.join(dir, 'errors.jsonl');
+    fs.appendFileSync(errorsFile, JSON.stringify(record) + '\n');
+  } catch {
+    // Never crash the user's app
+  }
+}
+
 /**
  * Emit a type payload for a single Express route invocation.
  */
@@ -104,6 +153,7 @@ function emitExpressPayload(
   input: Record<string, unknown>,
   output: unknown,
   error?: unknown,
+  durationMs?: number,
 ): void {
   try {
     const functionKey = `express::${functionName}`;
@@ -132,6 +182,10 @@ function emitExpressPayload(
       sampleOutput: error ? undefined : sanitizeSample(output),
     };
 
+    if (durationMs !== undefined) {
+      payload.durationMs = Math.round(durationMs * 100) / 100;
+    }
+
     if (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       payload.error = {
@@ -140,6 +194,8 @@ function emitExpressPayload(
         stackTrace: err.stack,
         argsSnapshot: sanitizeSample(input),
       };
+      // Also write to errors.jsonl for monitor/heal detection
+      writeErrorToFile(error, input, functionName);
     }
 
     enqueue(payload);
@@ -163,8 +219,29 @@ function wrapExpressHandler(
       return handler.call(this, req, res, next);
     }
 
+    const self = this;
+
+    // Wrap entire handler execution in request context so downstream calls get a request ID
+    let returnValue: any;
+    withRequestContext(req, () => {
+      returnValue = _executeHandler(self, handler, req, res, next, routeName, opts);
+    });
+    return returnValue;
+  };
+
+  function _executeHandler(
+    self: any,
+    handler: Function,
+    req: any,
+    res: any,
+    next: any,
+    routeName: string,
+    opts: ExpressInstrumentOpts,
+  ): any {
     const input = extractRequestInput(req);
     let captured = false;
+    const startTime = performance.now();
+    const callId = traceCall(routeName, 'express');
 
     // Intercept res.json()
     const originalJson = res.json;
@@ -172,7 +249,9 @@ function wrapExpressHandler(
       res.json = function (data: any) {
         if (!captured) {
           captured = true;
-          emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, data);
+          const durationMs = performance.now() - startTime;
+          traceReturn(callId, routeName, 'express', durationMs);
+          emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, data, undefined, durationMs);
         }
         res.json = originalJson; // restore
         return originalJson.call(res, data);
@@ -185,9 +264,11 @@ function wrapExpressHandler(
       res.send = function (data: any) {
         if (!captured) {
           captured = true;
+          const durationMs = performance.now() - startTime;
+          traceReturn(callId, routeName, 'express', durationMs);
           // Only capture non-string data as typed output; strings are usually HTML
           const output = typeof data === 'string' ? { __html: true } : data;
-          emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, output);
+          emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, output, undefined, durationMs);
         }
         res.send = originalSend; // restore
         return originalSend.call(res, data);
@@ -198,7 +279,9 @@ function wrapExpressHandler(
     const wrappedNext = function (err?: any) {
       if (err && !captured) {
         captured = true;
-        emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err);
+        const durationMs = performance.now() - startTime;
+        traceReturn(callId, routeName, 'express', durationMs, (err instanceof Error ? err : new Error(String(err))).message);
+        emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err, durationMs);
       }
       if (typeof next === 'function') {
         return next(err);
@@ -206,14 +289,16 @@ function wrapExpressHandler(
     };
 
     try {
-      const result = handler.call(this, req, res, wrappedNext);
+      const result = handler.call(self, req, res, wrappedNext);
 
       // Handle async handlers that return a promise
       if (result && typeof result === 'object' && typeof result.then === 'function') {
         return result.catch((err: unknown) => {
           if (!captured) {
             captured = true;
-            emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err);
+            const durationMs = performance.now() - startTime;
+            traceReturn(callId, routeName, 'express', durationMs, (err instanceof Error ? err : new Error(String(err))).message);
+            emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err, durationMs);
           }
           // Re-throw so Express error handling picks it up
           throw err;
@@ -224,11 +309,13 @@ function wrapExpressHandler(
     } catch (err) {
       if (!captured) {
         captured = true;
-        emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err);
+        const durationMs = performance.now() - startTime;
+        traceReturn(callId, routeName, 'express', durationMs, (err instanceof Error ? err : new Error(String(err))).message);
+        emitExpressPayload(routeName, opts.environment, opts.maxDepth, input, undefined, err, durationMs);
       }
       throw err;
     }
-  };
+  }
 
   // Preserve function metadata
   Object.defineProperty(wrapped, 'name', { value: handler.name || routeName, configurable: true });
@@ -335,17 +422,9 @@ export function trickleMiddleware(
     }
 
     // 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);
+    withRequestContext(req, () => {
+      _handleRequest(req, res, next, opts, debug);
+    });
   };
 }
 
@@ -355,6 +434,9 @@ function _handleRequest(req: any, res: any, next: any, opts: any, debug: boolean
     }
 
     let captured = false;
+    const startTime = performance.now();
+    const prelimRouteName = `${req.method || 'UNKNOWN'} ${req.originalUrl || req.url || '/'}`;
+    const callId = traceCall(prelimRouteName, 'express');
 
     // We derive the route name lazily once the response is being sent,
     // because req.route is only populated after the handler matches.
@@ -366,7 +448,7 @@ function _handleRequest(req: any, res: any, next: any, opts: any, debug: boolean
       } catch {
         // ignore
       }
-      return `${req.method || 'UNKNOWN'} ${req.originalUrl || req.url || '/'}`;
+      return prelimRouteName;
     }
 
     const input = extractRequestInput(req);
@@ -378,12 +460,14 @@ function _handleRequest(req: any, res: any, next: any, opts: any, debug: boolean
         if (!captured) {
           captured = true;
           const routeName = getRouteName();
+          const durationMs = performance.now() - startTime;
+          traceReturn(callId, routeName, 'express', durationMs);
           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);
+          emitExpressPayload(routeName, opts.environment, opts.maxDepth, latestInput, data, undefined, durationMs);
         }
         res.json = originalJson;
         return originalJson.call(res, data);
@@ -399,12 +483,14 @@ function _handleRequest(req: any, res: any, next: any, opts: any, debug: boolean
         if (!captured) {
           captured = true;
           const routeName = getRouteName();
+          const durationMs = performance.now() - startTime;
+          traceReturn(callId, routeName, 'express', durationMs);
           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);
+          emitExpressPayload(routeName, opts.environment, opts.maxDepth, latestInput, output, undefined, durationMs);
         }
         res.send = originalSend;
         return originalSend.call(res, data);

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

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

package/dist/vite-plugin.test.js

@@ -1,160 +0,0 @@
-"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');
-    });
-});