node-loop-detective 1.3.0 → 1.5.0

package/README.md

@@ -77,6 +77,9 @@ loop-detective -p 12345 --io-threshold 1000
 # Connect to a remote inspector (Docker, K8s, remote server)
 loop-detective --host 192.168.1.100 --port 9229
 
+# Save raw CPU profile for Chrome DevTools / speedscope
+loop-detective -p 12345 --save-profile ./profile.cpuprofile
+
 # Continuous monitoring mode
 loop-detective -p 12345 --watch
 
@@ -95,6 +98,7 @@ loop-detective -p 12345 --json
 | `-t, --threshold <ms>` | Event loop lag threshold | 50 |
 | `-i, --interval <ms>` | Lag sampling interval | 100 |
 | `--io-threshold <ms>` | Slow I/O threshold | 500 |
+| `--save-profile <path>` | Save raw CPU profile to file | — |
 | `-j, --json` | Output as JSON | false |
 | `-w, --watch` | Continuous monitoring | false |
 
@@ -116,7 +120,8 @@ loop-detective -p 12345 --json
 | Type | What It Tracks |
 |------|---------------|
 | 🌐 HTTP/HTTPS | Outgoing HTTP requests — method, target, status code, duration |
-| 🔍 DNS | DNS lookups — hostname, resolution time |
+| 🌐 Fetch | Global `fetch()` calls (Node.js 18+) — method, target, status, duration |
+| 🔍 DNS | DNS lookups — callback and promise API (`dns.lookup` + `dns.promises.lookup`) |
 | 🔌 TCP | TCP connections — target host:port, connect time (covers databases, Redis, etc.) |
 
 Each slow I/O event includes the caller stack trace, so you know exactly which code initiated the slow operation.

package/bin/cli.js

@@ -4,6 +4,8 @@
 
 const { Detective } = require('../src/detective');
 const { Reporter } = require('../src/reporter');
+const fs = require('node:fs');
+const path = require('node:path');
 
 // Simple arg parser compatible with Node.js 16+
 function parseCliArgs(argv) {
@@ -16,6 +18,7 @@ function parseCliArgs(argv) {
     threshold: '50',
     interval: '100',
     'io-threshold': '500',
+    'save-profile': null,
     json: false,
     watch: false,
     help: false,
@@ -31,6 +34,7 @@ function parseCliArgs(argv) {
     '-t': 'threshold', '--threshold': 'threshold',
     '-i': 'interval', '--interval': 'interval',
     '--io-threshold': 'io-threshold',
+    '--save-profile': 'save-profile',
   };
   const boolMap = {
     '-j': 'json', '--json': 'json',
@@ -97,6 +101,7 @@ function printUsage() {
     -t, --threshold <ms>     Event loop lag threshold in ms (default: 50)
     -i, --interval <ms>      Sampling interval in ms (default: 100)
     --io-threshold <ms>      Slow I/O threshold in ms (default: 500)
+    --save-profile <path>    Save raw CPU profile to .cpuprofile file
     -j, --json               Output results as JSON
     -w, --watch              Continuous monitoring mode
     -h, --help               Show this help
@@ -127,6 +132,7 @@ async function main() {
     threshold: parseInt(values.threshold, 10),
     interval: parseInt(values.interval, 10),
     ioThreshold: parseInt(values['io-threshold'], 10),
+    saveProfile: values['save-profile'],
     watch: values.watch,
     json: values.json,
   };
@@ -142,7 +148,24 @@ async function main() {
   detective.on('connected', () => reporter.onConnected());
   detective.on('lag', (data) => reporter.onLag(data));
   detective.on('slowIO', (data) => reporter.onSlowIO(data));
-  detective.on('profile', (data) => reporter.onProfile(data));
+  detective.on('profile', (analysis, rawProfile) => {
+    reporter.onProfile(analysis);
+
+    // Save raw CPU profile if requested
+    if (config.saveProfile && rawProfile) {
+      try {
+        const filePath = path.resolve(config.saveProfile);
+        fs.writeFileSync(filePath, JSON.stringify(rawProfile));
+        if (!config.json) {
+          console.log(`\n  \x1b[32m✔\x1b[0m CPU profile saved to ${filePath}`);
+          console.log(`    Open in Chrome DevTools: Performance tab → Load profile`);
+          console.log(`    Or visit https://www.speedscope.app\n`);
+        }
+      } catch (err) {
+        console.error(`\n  \x1b[31m✖ Failed to save profile: ${err.message}\x1b[0m\n`);
+      }
+    }
+  });
   detective.on('error', (err) => reporter.onError(err));
   detective.on('disconnected', () => reporter.onDisconnected());
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-loop-detective",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "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

@@ -261,7 +261,7 @@ class Detective extends EventEmitter {
         patchHttp('http');
         patchHttp('https');
 
-        // --- Track DNS lookups ---
+        // --- Track DNS lookups (callback API) ---
         (function patchDns() {
           let dns;
           try { dns = require('dns'); } catch { return; }
@@ -287,6 +287,40 @@ class Detective extends EventEmitter {
               if (callback) callback(err, address, family);
             });
           };
+
+          // --- Track DNS lookups (promise API, Node.js 10.6+) ---
+          if (dns.promises && dns.promises.lookup) {
+            const origPromiseLookup = dns.promises.lookup;
+            originals['dns.promises.lookup'] = { mod: dns.promises, key: 'lookup', fn: origPromiseLookup };
+
+            dns.promises.lookup = function patchedPromiseLookup(hostname, options) {
+              const startTime = Date.now();
+              const callerStack = captureCallerStack();
+
+              return origPromiseLookup.call(dns.promises, hostname, options).then(
+                (result) => {
+                  const duration = Date.now() - startTime;
+                  if (duration >= threshold) {
+                    recordSlowOp({
+                      type: 'dns', target: hostname, duration,
+                      timestamp: Date.now(), stack: callerStack,
+                    });
+                  }
+                  return result;
+                },
+                (err) => {
+                  const duration = Date.now() - startTime;
+                  if (duration >= threshold) {
+                    recordSlowOp({
+                      type: 'dns', target: hostname, duration,
+                      error: err.message, timestamp: Date.now(), stack: callerStack,
+                    });
+                  }
+                  throw err;
+                }
+              );
+            };
+          }
         })();
 
         // --- Track TCP socket connections ---
@@ -320,10 +354,63 @@ class Detective extends EventEmitter {
           };
         })();
 
+        // --- Track global fetch() (Node.js 18+) ---
+        (function patchFetch() {
+          if (typeof globalThis.fetch !== 'function') return;
+          const origFetch = globalThis.fetch;
+          originals['globalThis.fetch'] = { mod: globalThis, key: 'fetch', fn: origFetch };
+
+          globalThis.fetch = function patchedFetch(input, init) {
+            const startTime = Date.now();
+            const callerStack = captureCallerStack();
+
+            // Extract target URL
+            let target = 'unknown';
+            let method = 'GET';
+            if (typeof input === 'string') {
+              target = input;
+            } else if (input && typeof input === 'object') {
+              target = input.url || input.href || String(input);
+              method = (input.method || 'GET').toUpperCase();
+            }
+            if (init && init.method) {
+              method = init.method.toUpperCase();
+            }
+            // Shorten target for display
+            try {
+              const u = new URL(target);
+              target = u.host + u.pathname;
+            } catch {}
+
+            return origFetch.call(this, input, init).then(
+              (res) => {
+                const duration = Date.now() - startTime;
+                if (duration >= threshold) {
+                  recordSlowOp({
+                    type: 'fetch', method, target,
+                    statusCode: res.status, duration, timestamp: Date.now(), stack: callerStack,
+                  });
+                }
+                return res;
+              },
+              (err) => {
+                const duration = Date.now() - startTime;
+                if (duration >= threshold) {
+                  recordSlowOp({
+                    type: 'fetch', method, target,
+                    error: err.message, duration, timestamp: Date.now(), stack: callerStack,
+                  });
+                }
+                throw err;
+              }
+            );
+          };
+        })();
+
         globalThis.__loopDetectiveIO = {
           getSlowOps: () => slowOps.splice(0),
           cleanup: () => {
-            // Fix #1: Restore all original functions
+            // Restore all original functions
             for (const entry of Object.values(originals)) {
               entry.mod[entry.key] = entry.fn;
             }
@@ -424,7 +511,7 @@ class Detective extends EventEmitter {
 
       const profile = await this._captureProfile(this.config.duration);
       const analysis = this.analyzer.analyzeProfile(profile);
-      this.emit('profile', analysis);
+      this.emit('profile', analysis, profile);
     } finally {
       await this.stop();
     }
@@ -444,7 +531,7 @@ class Detective extends EventEmitter {
       try {
         const profile = await this._captureProfile(this.config.duration);
         const analysis = this.analyzer.analyzeProfile(profile);
-        this.emit('profile', analysis);
+        this.emit('profile', analysis, profile);
       } catch (err) {
         this.emit('error', err);
       }

package/src/reporter.js

@@ -45,8 +45,8 @@ class Reporter {
     this.slowIOEvents.push(data);
     if (this.config.json) return;
     const severity = data.duration > 5000 ? COLORS.red : data.duration > 2000 ? COLORS.yellow : COLORS.magenta;
-    const icon = data.type === 'http' ? '🌐' : data.type === 'dns' ? '🔍' : '🔌';
-    const detail = data.type === 'http'
+    const icon = data.type === 'http' ? '🌐' : data.type === 'fetch' ? '🌐' : data.type === 'dns' ? '🔍' : '🔌';
+    const detail = data.type === 'http' || data.type === 'fetch'
       ? `${data.method} ${data.target} → ${data.statusCode || data.error || '?'}`
       : data.type === 'dns'
       ? `lookup ${data.target}${data.error ? ' (' + data.error + ')' : ''}`
@@ -177,7 +177,7 @@ class Reporter {
     }
 
     for (const [type, ops] of Object.entries(byType)) {
-      const icon = type === 'http' ? '🌐' : type === 'dns' ? '🔍' : '🔌';
+      const icon = type === 'http' ? '🌐' : type === 'fetch' ? '🌐' : type === 'dns' ? '🔍' : '🔌';
       const maxDur = Math.max(...ops.map(o => o.duration));
       const avgDur = Math.round(ops.reduce((s, o) => s + o.duration, 0) / ops.length);
       this._print(`\n    ${icon} ${COLORS.bold}${type.toUpperCase()}${COLORS.reset} — ${ops.length} slow ops, avg ${avgDur}ms, max ${maxDur}ms`);
@@ -185,7 +185,7 @@ class Reporter {
       // Group by target
       const byTarget = {};
       for (const op of ops) {
-        const key = op.type === 'http' ? `${op.method} ${op.target}` : op.target;
+        const key = (op.type === 'http' || op.type === 'fetch') ? `${op.method} ${op.target}` : op.target;
         if (!byTarget[key]) byTarget[key] = { count: 0, totalDuration: 0, maxDuration: 0, errors: 0, stack: op.stack };
         byTarget[key].count++;
         byTarget[key].totalDuration += op.duration;