trickle-observe 0.2.89 → 0.2.91

package/dist/trace-var.js

@@ -238,4 +238,61 @@ if (typeof process !== 'undefined' && process.on) {
     process.on('beforeExit', exitFlush);
     process.on('SIGTERM', exitFlush);
     process.on('SIGINT', exitFlush);
+    // Capture uncaught exceptions with variable context for agent debugging.
+    // Write error + nearby variable values to errors.jsonl before the process exits.
+    process.on('uncaughtException', (err) => {
+        flushVarBuffer();
+        try {
+            const dir = varsFilePath
+                ? path.dirname(varsFilePath)
+                : process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            catch { }
+            const errorsFile = path.join(dir, 'errors.jsonl');
+            // 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')) {
+                    errorFile = m[1];
+                    errorLine = parseInt(m[2]);
+                    break;
+                }
+            }
+            // Find nearby variable values from the cache
+            const nearbyVars = {};
+            if (errorFile && errorLine) {
+                for (const [key, entry] of varCache) {
+                    const parts = key.split(':');
+                    const file = parts[0];
+                    const line = parseInt(parts[1]);
+                    const varName = parts.slice(2).join(':');
+                    if (file === errorFile && Math.abs(line - errorLine) <= 10) {
+                        nearbyVars[`L${parts[1]} ${varName}`] = entry.fp;
+                    }
+                }
+            }
+            const record = {
+                kind: 'error',
+                error: err.message,
+                type: err.constructor.name,
+                file: errorFile,
+                line: errorLine,
+                stack: stackLines.slice(0, 6).join('\n'),
+                nearbyVariables: Object.keys(nearbyVars).length > 0 ? nearbyVars : undefined,
+                timestamp: new Date().toISOString(),
+            };
+            fs.appendFileSync(errorsFile, JSON.stringify(record) + '\n');
+        }
+        catch {
+            // Never suppress the original error
+        }
+        // Print the original error and exit (don't re-throw to preserve original stack)
+        console.error(err.stack || err.message);
+        process.exit(1);
+    });
 }

package/dist/types.d.ts

@@ -42,6 +42,7 @@ export interface IngestPayload {
     paramNames?: string[];
     sampleInput?: unknown;
     sampleOutput?: unknown;
+    durationMs?: number;
     error?: {
         type: string;
         message: string;

package/dist/wrap.js

@@ -32,6 +32,7 @@ function wrapFunction(fn, opts) {
         let threwError = false;
         let caughtError;
         const trackers = [];
+        const startTime = performance.now();
         try {
             // Always pass ORIGINAL args to the function — never proxied ones.
             // Proxied args can break framework internals (Express Router, DI containers, etc.)
@@ -40,9 +41,10 @@ function wrapFunction(fn, opts) {
         catch (err) {
             threwError = true;
             caughtError = err;
-            // Capture error context
+            // Capture error context with timing
             try {
-                captureErrorPayload(functionKey, opts, args, trackers, err);
+                const durationMs = performance.now() - startTime;
+                captureErrorPayload(functionKey, opts, args, trackers, err, durationMs);
             }
             catch {
                 // Never let our instrumentation interfere
@@ -54,7 +56,8 @@ function wrapFunction(fn, opts) {
         if (result !== null && result !== undefined && typeof result === 'object' && typeof result.then === 'function') {
             return result.then((resolved) => {
                 try {
-                    capturePayload(functionKey, opts, args, trackers, resolved, true);
+                    const durationMs = performance.now() - startTime;
+                    capturePayload(functionKey, opts, args, trackers, resolved, true, durationMs);
                 }
                 catch {
                     // Never let our instrumentation interfere
@@ -62,7 +65,8 @@ function wrapFunction(fn, opts) {
                 return resolved;
             }, (err) => {
                 try {
-                    captureErrorPayload(functionKey, opts, args, trackers, err);
+                    const durationMs = performance.now() - startTime;
+                    captureErrorPayload(functionKey, opts, args, trackers, err, durationMs);
                 }
                 catch {
                     // Never let our instrumentation interfere
@@ -73,7 +77,8 @@ function wrapFunction(fn, opts) {
         }
         // Synchronous return
         try {
-            capturePayload(functionKey, opts, args, trackers, result);
+            const durationMs = performance.now() - startTime;
+            capturePayload(functionKey, opts, args, trackers, result, false, durationMs);
         }
         catch {
             // Never let our instrumentation interfere
@@ -90,7 +95,7 @@ function wrapFunction(fn, opts) {
 /**
  * Capture and enqueue a successful invocation's type data.
  */
-function capturePayload(functionKey, opts, originalArgs, trackers, returnValue, isAsync = false) {
+function capturePayload(functionKey, opts, originalArgs, trackers, returnValue, isAsync = false, durationMs) {
     // Build args type as a tuple
     const argsType = buildArgsType(originalArgs, trackers, opts.maxDepth);
     const returnType = (0, type_inference_1.inferType)(returnValue, opts.maxDepth);
@@ -117,12 +122,15 @@ function capturePayload(functionKey, opts, originalArgs, trackers, returnValue,
     if (opts.paramNames && opts.paramNames.length > 0) {
         payload.paramNames = opts.paramNames;
     }
+    if (durationMs !== undefined) {
+        payload.durationMs = Math.round(durationMs * 100) / 100;
+    }
     (0, transport_1.enqueue)(payload);
 }
 /**
  * Capture type context for a failed invocation.
  */
-function captureErrorPayload(functionKey, opts, originalArgs, trackers, error) {
+function captureErrorPayload(functionKey, opts, originalArgs, trackers, error, durationMs) {
     const argsType = buildArgsType(originalArgs, trackers, opts.maxDepth);
     const returnType = { kind: 'unknown' };
     const hash = (0, type_hash_1.hashType)(argsType, returnType);

package/package.json

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

package/src/trace-var.ts

@@ -221,4 +221,61 @@ if (typeof process !== 'undefined' && process.on) {
   process.on('beforeExit', exitFlush);
   process.on('SIGTERM', exitFlush);
   process.on('SIGINT', exitFlush);
+
+  // Capture uncaught exceptions with variable context for agent debugging.
+  // Write error + nearby variable values to errors.jsonl before the process exits.
+  process.on('uncaughtException', (err: Error) => {
+    flushVarBuffer();
+    try {
+      const dir = varsFilePath
+        ? path.dirname(varsFilePath)
+        : process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+      try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+      const errorsFile = path.join(dir, 'errors.jsonl');
+
+      // 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')) {
+          errorFile = m[1];
+          errorLine = parseInt(m[2]);
+          break;
+        }
+      }
+
+      // Find nearby variable values from the cache
+      const nearbyVars: Record<string, string> = {};
+      if (errorFile && errorLine) {
+        for (const [key, entry] of varCache) {
+          const parts = key.split(':');
+          const file = parts[0];
+          const line = parseInt(parts[1]);
+          const varName = parts.slice(2).join(':');
+          if (file === errorFile && Math.abs(line - errorLine) <= 10) {
+            nearbyVars[`L${parts[1]} ${varName}`] = entry.fp;
+          }
+        }
+      }
+
+      const record = {
+        kind: 'error',
+        error: err.message,
+        type: err.constructor.name,
+        file: errorFile,
+        line: errorLine,
+        stack: stackLines.slice(0, 6).join('\n'),
+        nearbyVariables: Object.keys(nearbyVars).length > 0 ? nearbyVars : undefined,
+        timestamp: new Date().toISOString(),
+      };
+      fs.appendFileSync(errorsFile, JSON.stringify(record) + '\n');
+    } catch {
+      // Never suppress the original error
+    }
+    // Print the original error and exit (don't re-throw to preserve original stack)
+    console.error(err.stack || err.message);
+    process.exit(1);
+  });
 }

package/src/types.ts

@@ -22,6 +22,7 @@ export interface IngestPayload {
   paramNames?: string[];
   sampleInput?: unknown;
   sampleOutput?: unknown;
+  durationMs?: number;
   error?: {
     type: string;
     message: string;

package/src/wrap.ts

@@ -34,6 +34,7 @@ export function wrapFunction<T extends (...args: any[]) => any>(fn: T, opts: Wra
     let threwError = false;
     let caughtError: unknown;
     const trackers: Array<{ proxy: unknown; getAccessedPaths: () => Map<string, TypeNode> }> = [];
+    const startTime = performance.now();
 
     try {
       // Always pass ORIGINAL args to the function — never proxied ones.
@@ -43,9 +44,10 @@ export function wrapFunction<T extends (...args: any[]) => any>(fn: T, opts: Wra
       threwError = true;
       caughtError = err;
 
-      // Capture error context
+      // Capture error context with timing
       try {
-        captureErrorPayload(functionKey, opts, args, trackers, err);
+        const durationMs = performance.now() - startTime;
+        captureErrorPayload(functionKey, opts, args, trackers, err, durationMs);
       } catch {
         // Never let our instrumentation interfere
       }
@@ -59,7 +61,8 @@ export function wrapFunction<T extends (...args: any[]) => any>(fn: T, opts: Wra
       return result.then(
         (resolved: unknown) => {
           try {
-            capturePayload(functionKey, opts, args, trackers, resolved, true);
+            const durationMs = performance.now() - startTime;
+            capturePayload(functionKey, opts, args, trackers, resolved, true, durationMs);
           } catch {
             // Never let our instrumentation interfere
           }
@@ -67,7 +70,8 @@ export function wrapFunction<T extends (...args: any[]) => any>(fn: T, opts: Wra
         },
         (err: unknown) => {
           try {
-            captureErrorPayload(functionKey, opts, args, trackers, err);
+            const durationMs = performance.now() - startTime;
+            captureErrorPayload(functionKey, opts, args, trackers, err, durationMs);
           } catch {
             // Never let our instrumentation interfere
           }
@@ -79,7 +83,8 @@ export function wrapFunction<T extends (...args: any[]) => any>(fn: T, opts: Wra
 
     // Synchronous return
     try {
-      capturePayload(functionKey, opts, args, trackers, result);
+      const durationMs = performance.now() - startTime;
+      capturePayload(functionKey, opts, args, trackers, result, false, durationMs);
     } catch {
       // Never let our instrumentation interfere
     }
@@ -107,6 +112,7 @@ function capturePayload(
   trackers: Array<{ proxy: unknown; getAccessedPaths: () => Map<string, TypeNode> }>,
   returnValue: unknown,
   isAsync: boolean = false,
+  durationMs?: number,
 ): void {
   // Build args type as a tuple
   const argsType = buildArgsType(originalArgs, trackers, opts.maxDepth);
@@ -141,6 +147,10 @@ function capturePayload(
     payload.paramNames = opts.paramNames;
   }
 
+  if (durationMs !== undefined) {
+    payload.durationMs = Math.round(durationMs * 100) / 100;
+  }
+
   enqueue(payload);
 }
 
@@ -153,6 +163,7 @@ function captureErrorPayload(
   originalArgs: unknown[],
   trackers: Array<{ proxy: unknown; getAccessedPaths: () => Map<string, TypeNode> }>,
   error: unknown,
+  durationMs?: number,
 ): void {
   const argsType = buildArgsType(originalArgs, trackers, opts.maxDepth);
   const returnType: TypeNode = { kind: 'unknown' };