node-loop-detective 1.0.0 → 1.0.2

package/bin/cli.js

@@ -2,32 +2,58 @@
 
 'use strict';
 
-const { parseArgs } = require('node:util');
 const { Detective } = require('../src/detective');
 const { Reporter } = require('../src/reporter');
 
-const options = {
-  pid: { type: 'string', short: 'p' },
-  port: { type: 'string', short: 'P', default: '' },
-  duration: { type: 'string', short: 'd', default: '10' },
-  threshold: { type: 'string', short: 't', default: '50' },
-  interval: { type: 'string', short: 'i', default: '100' },
-  json: { type: 'boolean', short: 'j', default: false },
-  watch: { type: 'boolean', short: 'w', default: false },
-  help: { type: 'boolean', short: 'h', default: false },
-  version: { type: 'boolean', short: 'v', default: false },
-};
-
-let parsed;
-try {
-  parsed = parseArgs({ options, allowPositionals: true });
-} catch (err) {
-  console.error(`Error: ${err.message}\n`);
-  printUsage();
-  process.exit(1);
+// Simple arg parser compatible with Node.js 16+
+function parseCliArgs(argv) {
+  const args = argv.slice(2);
+  const values = {
+    pid: null,
+    port: null,
+    duration: '10',
+    threshold: '50',
+    interval: '100',
+    json: false,
+    watch: false,
+    help: false,
+    version: false,
+  };
+  const positionals = [];
+
+  const flagMap = {
+    '-p': 'pid', '--pid': 'pid',
+    '-P': 'port', '--port': 'port',
+    '-d': 'duration', '--duration': 'duration',
+    '-t': 'threshold', '--threshold': 'threshold',
+    '-i': 'interval', '--interval': 'interval',
+  };
+  const boolMap = {
+    '-j': 'json', '--json': 'json',
+    '-w': 'watch', '--watch': 'watch',
+    '-h': 'help', '--help': 'help',
+    '-v': 'version', '--version': 'version',
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (flagMap[arg]) {
+      values[flagMap[arg]] = args[++i] || '';
+    } else if (boolMap[arg]) {
+      values[boolMap[arg]] = true;
+    } else if (!arg.startsWith('-')) {
+      positionals.push(arg);
+    } else {
+      console.error(`Unknown option: ${arg}\n`);
+      printUsage();
+      process.exit(1);
+    }
+  }
+
+  return { values, positionals };
 }
 
-const { values, positionals } = parsed;
+const { values, positionals } = parseCliArgs(process.argv);
 
 if (values.version) {
   const pkg = require('../package.json');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-loop-detective",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Detect event loop blocking & lag in running Node.js apps without code changes or restarts",
   "main": "src/index.js",
   "bin": {

package/src/detective.js

@@ -56,7 +56,7 @@ class Detective extends EventEmitter {
    * We inject a tiny lag-measuring snippet into the target process
    */
   async _startLagDetection() {
-    // Inject a lag detector into the target process
+    // Inject a lag detector that also captures stack traces
     const script = `
       (function() {
         if (globalThis.__loopDetective) {
@@ -66,12 +66,33 @@ class Detective extends EventEmitter {
         let lastTime = Date.now();
         const threshold = ${this.config.threshold};
 
+        // Capture stack trace at the point of lag detection
+        function captureStack() {
+          const orig = Error.stackTraceLimit;
+          Error.stackTraceLimit = 20;
+          const err = new Error();
+          Error.stackTraceLimit = orig;
+          // Parse the stack into structured frames
+          const frames = (err.stack || '').split('\\n').slice(2).map(line => {
+            const m = line.match(/at\\s+(?:(.+?)\\s+\\()?(.+?):(\\d+):(\\d+)\\)?/);
+            if (m) return { fn: m[1] || '(anonymous)', file: m[2], line: +m[3], col: +m[4] };
+            const m2 = line.match(/at\\s+(.+)/);
+            if (m2) return { fn: m2[1], file: '', line: 0, col: 0 };
+            return null;
+          }).filter(Boolean).filter(f =>
+            !f.file.includes('loopDetective') &&
+            !f.fn.includes('Timeout.') &&
+            !f.file.includes('node:internal')
+          );
+          return frames;
+        }
+
         const timer = setInterval(() => {
           const now = Date.now();
           const delta = now - lastTime;
           const lag = delta - ${this.config.interval};
           if (lag > threshold) {
-            lags.push({ lag, timestamp: now });
+            lags.push({ lag, timestamp: now, stack: captureStack() });
             if (lags.length > 100) lags.shift();
           }
           lastTime = now;

package/src/reporter.js

@@ -33,6 +33,11 @@ class Reporter {
     if (this.config.json) return;
     const severity = data.lag > 500 ? COLORS.red : data.lag > 200 ? COLORS.yellow : COLORS.cyan;
     this._print(`${severity}⚠ Event loop lag: ${data.lag}ms${COLORS.reset} ${COLORS.dim}at ${new Date(data.timestamp).toISOString()}${COLORS.reset}`);
+    if (data.stack && data.stack.length > 0) {
+      for (const frame of data.stack.slice(0, 5)) {
+        this._print(`  ${COLORS.dim}  → ${frame.fn} ${frame.file}:${frame.line}:${frame.col}${COLORS.reset}`);
+      }
+    }
   }
 
   onProfile(analysis) {
@@ -143,6 +148,29 @@ class Reporter {
       this._print(`    Events: ${this.lagEvents.length}`);
       this._print(`    Max:    ${maxLag}ms`);
       this._print(`    Avg:    ${avgLag}ms`);
+
+      // Aggregate lag by code location
+      const locationMap = new Map();
+      for (const evt of this.lagEvents) {
+        if (evt.stack && evt.stack.length > 0) {
+          const top = evt.stack[0];
+          const key = `${top.fn} ${top.file}:${top.line}`;
+          const entry = locationMap.get(key) || { count: 0, totalLag: 0, maxLag: 0, frame: top };
+          entry.count++;
+          entry.totalLag += evt.lag;
+          entry.maxLag = Math.max(entry.maxLag, evt.lag);
+          locationMap.set(key, entry);
+        }
+      }
+
+      if (locationMap.size > 0) {
+        this._print(`\n    ${COLORS.bold}Lag by Code Location:${COLORS.reset}`);
+        const sorted = [...locationMap.values()].sort((a, b) => b.totalLag - a.totalLag);
+        for (const loc of sorted.slice(0, 5)) {
+          this._print(`    ${COLORS.yellow}${loc.frame.fn}${COLORS.reset} ${COLORS.dim}${loc.frame.file}:${loc.frame.line}${COLORS.reset}`);
+          this._print(`      ${loc.count} events, total ${loc.totalLag}ms, max ${loc.maxLag}ms`);
+        }
+      }
     }
 
     this._print(`\n${'─'.repeat(60)}\n`);