node-loop-detective 1.0.2 → 1.2.0

package/README.md

@@ -1,6 +1,6 @@
 # node-loop-detective 🔍
 
-Detect event loop blocking & lag in **running** Node.js apps — without code changes or restarts.
+Detect event loop blocking, lag, and slow async I/O in **running** Node.js apps — without code changes or restarts.
 
 ```
 $ loop-detective 12345
@@ -10,6 +10,8 @@ $ loop-detective 12345
 
 ⚠ Event loop lag: 312ms at 2025-01-15T10:23:45.123Z
 ⚠ Event loop lag: 156ms at 2025-01-15T10:23:48.456Z
+🌐 Slow HTTP: 2340ms GET api.example.com/users → 200
+🔌 Slow TCP: 1520ms db-server:3306
 
 ────────────────────────────────────────────────────────────
   Event Loop Detective Report
@@ -28,6 +30,17 @@ $ loop-detective 12345
    1. heavyComputation
       ██████████████░░░░░░ 6245ms (62.3%)
       /app/server.js:42:1
+
+  ⚠ Slow Async I/O Summary
+    Total slow ops: 3
+
+    🌐 HTTP — 2 slow ops, avg 1800ms, max 2340ms
+      GET api.example.com/users
+        2 calls, total 3600ms, avg 1800ms, max 2340ms
+
+    🔌 TCP — 1 slow ops, avg 1520ms, max 1520ms
+      db-server:3306
+        1 calls, total 1520ms, max 1520ms
 ```
 
 ## How It Works
@@ -35,9 +48,10 @@ $ loop-detective 12345
 1. Sends `SIGUSR1` to activate the Node.js built-in inspector (or connects to `--port`)
 2. Connects via Chrome DevTools Protocol (CDP)
 3. Injects a lightweight event loop lag monitor
-4. Captures a CPU profile to identify blocking code
-5. Analyzes the profile for common blocking patterns
-6. Disconnects cleanly — minimal impact on your running app
+4. Tracks slow async I/O (HTTP, DNS, TCP) via monkey-patching
+5. Captures a CPU profile to identify blocking code
+6. Analyzes the profile for common blocking patterns
+7. Disconnects cleanly — minimal impact on your running app
 
 ## Install
 
@@ -57,6 +71,9 @@ loop-detective --port 9229
 # Profile for 30 seconds with 100ms lag threshold
 loop-detective -p 12345 -d 30 -t 100
 
+# Detect slow I/O with a 1-second threshold
+loop-detective -p 12345 --io-threshold 1000
+
 # Continuous monitoring mode
 loop-detective -p 12345 --watch
 
@@ -73,11 +90,14 @@ loop-detective -p 12345 --json
 | `-d, --duration <sec>` | Profiling duration in seconds | 10 |
 | `-t, --threshold <ms>` | Event loop lag threshold | 50 |
 | `-i, --interval <ms>` | Lag sampling interval | 100 |
+| `--io-threshold <ms>` | Slow I/O threshold | 500 |
 | `-j, --json` | Output as JSON | false |
 | `-w, --watch` | Continuous monitoring | false |
 
 ## What It Detects
 
+### CPU / Event Loop Blocking
+
 | Pattern | Description |
 |---------|-------------|
 | `cpu-hog` | Single function consuming >50% CPU |
@@ -87,6 +107,16 @@ loop-detective -p 12345 --json
 | `sync-io` | Synchronous file I/O calls |
 | `crypto-heavy` | CPU-intensive crypto operations |
 
+### Slow Async I/O
+
+| Type | What It Tracks |
+|------|---------------|
+| 🌐 HTTP/HTTPS | Outgoing HTTP requests — method, target, status code, duration |
+| 🔍 DNS | DNS lookups — hostname, resolution time |
+| 🔌 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.
+
 ## Programmatic API
 
 ```js
@@ -97,9 +127,11 @@ const detective = new Detective({
   duration: 10000,
   threshold: 50,
   interval: 100,
+  ioThreshold: 500,
 });
 
 detective.on('lag', (data) => console.log('Lag:', data.lag, 'ms'));
+detective.on('slowIO', (data) => console.log('Slow I/O:', data.type, data.target, data.duration, 'ms'));
 detective.on('profile', (analysis) => {
   console.log('Heavy functions:', analysis.heavyFunctions);
   console.log('Patterns:', analysis.blockingPatterns);
@@ -117,7 +149,7 @@ await detective.start();
 
 ## How is this different from clinic.js / 0x?
 
-Those are great tools, but they require you to **start** your app through them. `loop-detective` attaches to an **already running** process — perfect for production debugging.
+Those are great tools, but they require you to **start** your app through them. `loop-detective` attaches to an **already running** process — perfect for production debugging. It also tracks slow async I/O (HTTP, DNS, TCP) which those tools don't focus on.
 
 ## License
 

package/bin/cli.js

@@ -14,6 +14,7 @@ function parseCliArgs(argv) {
     duration: '10',
     threshold: '50',
     interval: '100',
+    'io-threshold': '500',
     json: false,
     watch: false,
     help: false,
@@ -27,6 +28,7 @@ function parseCliArgs(argv) {
     '-d': 'duration', '--duration': 'duration',
     '-t': 'threshold', '--threshold': 'threshold',
     '-i': 'interval', '--interval': 'interval',
+    '--io-threshold': 'io-threshold',
   };
   const boolMap = {
     '-j': 'json', '--json': 'json',
@@ -90,6 +92,7 @@ function printUsage() {
     -d, --duration <sec>     Profiling duration in seconds (default: 10)
     -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)
     -j, --json               Output results as JSON
     -w, --watch              Continuous monitoring mode
     -h, --help               Show this help
@@ -117,6 +120,7 @@ async function main() {
     duration: parseInt(values.duration, 10) * 1000,
     threshold: parseInt(values.threshold, 10),
     interval: parseInt(values.interval, 10),
+    ioThreshold: parseInt(values['io-threshold'], 10),
     watch: values.watch,
     json: values.json,
   };
@@ -126,6 +130,7 @@ 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('error', (err) => reporter.onError(err));
   detective.on('disconnected', () => reporter.onDisconnected());

package/package.json

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

package/src/analyzer.js

@@ -7,12 +7,6 @@ class Analyzer {
 
   /**
    * Analyze a V8 CPU profile to find blocking functions
-   *
-   * V8 CPU profile format:
-   * - nodes: array of { id, callFrame: { functionName, url, lineNumber, columnNumber }, hitCount, children }
-   * - startTime, endTime: microseconds
-   * - samples: array of node IDs (sampled at each tick)
-   * - timeDeltas: array of time deltas between samples (microseconds)
    */
   analyzeProfile(profile) {
     const { nodes, samples, timeDeltas, startTime, endTime } = profile;
@@ -22,7 +16,7 @@ class Analyzer {
       nodeMap.set(node.id, node);
     }
 
-    // Calculate total time per node
+    // Calculate total time per node (keyed by node ID)
     const timings = new Map();
     for (let i = 0; i < samples.length; i++) {
       const nodeId = samples[i];
@@ -30,7 +24,6 @@ class Analyzer {
       timings.set(nodeId, (timings.get(nodeId) || 0) + delta);
     }
 
-    // Build results: find heavy functions
     const totalDuration = endTime - startTime; // microseconds
     const heavyFunctions = [];
 
@@ -40,35 +33,30 @@ class Analyzer {
 
       const { functionName, url, lineNumber, columnNumber } = node.callFrame;
 
-      // Skip internal/idle nodes
       if (!url && !functionName) continue;
       if (functionName === '(idle)' || functionName === '(program)') continue;
-      if (functionName === '(garbage collector)') {
-        // GC is interesting — keep it
-      }
 
       const selfTimeMs = selfTime / 1000;
       const percentage = totalDuration > 0 ? (selfTime / totalDuration) * 100 : 0;
 
-      if (selfTimeMs < 1) continue; // skip trivial entries
+      if (selfTimeMs < 1) continue;
 
       heavyFunctions.push({
+        nodeId, // Fix #5: carry node ID for accurate call stack building
         functionName: functionName || '(anonymous)',
         url: url || '(native)',
-        lineNumber: lineNumber + 1, // V8 uses 0-based
+        lineNumber: lineNumber + 1,
         columnNumber: columnNumber + 1,
         selfTimeMs: Math.round(selfTimeMs * 100) / 100,
         percentage: Math.round(percentage * 100) / 100,
       });
     }
 
-    // Sort by self time descending
     heavyFunctions.sort((a, b) => b.selfTimeMs - a.selfTimeMs);
 
-    // Build call tree for the top blockers
-    const callStacks = this._buildCallStacks(nodeMap, timings, heavyFunctions.slice(0, 5));
+    // Fix #5: Pass node IDs to _buildCallStacks instead of matching by name
+    const callStacks = this._buildCallStacks(nodeMap, heavyFunctions.slice(0, 5));
 
-    // Detect event loop blocking patterns
     const blockingPatterns = this._detectPatterns(heavyFunctions, profile);
 
     return {
@@ -77,7 +65,8 @@ class Analyzer {
         samplesCount: samples.length,
         heavyFunctionCount: heavyFunctions.length,
       },
-      heavyFunctions: heavyFunctions.slice(0, 20),
+      // Strip nodeId from public output
+      heavyFunctions: heavyFunctions.slice(0, 20).map(({ nodeId, ...rest }) => rest),
       callStacks,
       blockingPatterns,
       timestamp: Date.now(),
@@ -85,9 +74,11 @@ class Analyzer {
   }
 
   /**
-   * Build call stacks for the heaviest functions
+   * Build call stacks for the heaviest functions.
+   * Fix for Issue #5: Uses node ID directly instead of matching by function name,
+   * which avoids incorrect matches for same-named functions or minified code.
    */
-  _buildCallStacks(nodeMap, timings, topFunctions) {
+  _buildCallStacks(nodeMap, topFunctions) {
     const stacks = [];
 
     // Build parent map
@@ -101,18 +92,7 @@ class Analyzer {
     }
 
     for (const fn of topFunctions) {
-      // Find the node matching this function
-      let targetNode = null;
-      for (const node of nodeMap.values()) {
-        const cf = node.callFrame;
-        if (cf.functionName === fn.functionName &&
-            cf.url === (fn.url === '(native)' ? '' : fn.url) &&
-            cf.lineNumber === fn.lineNumber - 1) {
-          targetNode = node;
-          break;
-        }
-      }
-
+      const targetNode = nodeMap.get(fn.nodeId);
       if (!targetNode) continue;
 
       // Walk up the call stack
@@ -149,7 +129,6 @@ class Analyzer {
     const patterns = [];
     const totalMs = (profile.endTime - profile.startTime) / 1000;
 
-    // Pattern: Single function dominating CPU
     const topFn = heavyFunctions[0];
     if (topFn && topFn.percentage > 50) {
       patterns.push({
@@ -161,7 +140,6 @@ class Analyzer {
       });
     }
 
-    // Pattern: JSON parsing / serialization
     const jsonFns = heavyFunctions.filter(
       (f) => f.functionName.includes('JSON') || f.functionName.includes('parse') || f.functionName.includes('stringify')
     );
@@ -175,7 +153,6 @@ class Analyzer {
       });
     }
 
-    // Pattern: RegExp heavy
     const regexFns = heavyFunctions.filter(
       (f) => f.functionName.includes('RegExp') || f.functionName.includes('exec') || f.functionName.includes('match')
     );
@@ -189,7 +166,6 @@ class Analyzer {
       });
     }
 
-    // Pattern: GC pressure
     const gcFns = heavyFunctions.filter((f) => f.functionName.includes('garbage collector'));
     const gcTime = gcFns.reduce((sum, f) => sum + f.selfTimeMs, 0);
     if (gcTime > totalMs * 0.05) {
@@ -201,7 +177,6 @@ class Analyzer {
       });
     }
 
-    // Pattern: Synchronous file I/O
     const syncFns = heavyFunctions.filter(
       (f) => f.functionName.includes('Sync') || f.url.includes('fs.js') || f.url.includes('node:fs')
     );
@@ -215,7 +190,6 @@ class Analyzer {
       });
     }
 
-    // Pattern: Crypto operations
     const cryptoFns = heavyFunctions.filter(
       (f) => f.url.includes('crypto') || f.functionName.includes('pbkdf') || f.functionName.includes('hash')
     );

package/src/detective.js

@@ -11,20 +11,22 @@ class Detective extends EventEmitter {
     this.inspector = null;
     this.analyzer = new Analyzer(config);
     this._running = false;
+    this._stopping = false;
     this._lagTimer = null;
+    this._ioTimer = null;
   }
 
   /**
    * Activate the inspector on the target process via SIGUSR1
    */
   _activateInspector() {
-    if (this.config.inspectorPort) return; // already specified
+    if (this.config.inspectorPort) return;
 
     const pid = this.config.pid;
     if (!pid) throw new Error('No PID provided');
 
     try {
-      process.kill(pid, 0); // check process exists
+      process.kill(pid, 0);
     } catch (err) {
       throw new Error(`Process ${pid} not found or not accessible: ${err.message}`);
     }
@@ -44,19 +46,21 @@ class Detective extends EventEmitter {
    */
   async _findInspectorPort() {
     if (this.config.inspectorPort) return this.config.inspectorPort;
-
-    // After SIGUSR1, Node.js opens inspector on 9229 by default
-    // Give it a moment to start
     await this._sleep(1000);
     return 9229;
   }
 
   /**
    * Start event loop lag detection via CDP Runtime.evaluate
-   * We inject a tiny lag-measuring snippet into the target process
+   *
+   * Note on stack traces (Issue #6): The setInterval callback fires AFTER
+   * blocking code has finished, so captureStack() captures the timer's own
+   * stack, not the blocking code's stack. The lag event stacks are best-effort
+   * context. For accurate blocking code identification, use the CPU profile
+   * analysis (heavyFunctions + callStacks) which is based on V8 sampling and
+   * reliably identifies the actual blocking functions.
    */
   async _startLagDetection() {
-    // Inject a lag detector that also captures stack traces
     const script = `
       (function() {
         if (globalThis.__loopDetective) {
@@ -66,13 +70,11 @@ 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] };
@@ -98,7 +100,6 @@ class Detective extends EventEmitter {
           lastTime = now;
         }, ${this.config.interval});
 
-        // Make sure our timer doesn't keep the process alive
         if (timer.unref) timer.unref();
 
         globalThis.__loopDetective = {
@@ -126,7 +127,6 @@ class Detective extends EventEmitter {
       throw new Error(`Failed to inject lag detector: ${JSON.stringify(result.exceptionDetails)}`);
     }
 
-    // Poll for lag events
     this._lagTimer = setInterval(async () => {
       if (!this._running) return;
       try {
@@ -144,6 +144,224 @@ class Detective extends EventEmitter {
     }, 1000);
   }
 
+  /**
+   * Start slow async I/O detection via CDP Runtime.evaluate
+   * Monkey-patches http, https, net, dns to track slow operations
+   *
+   * Fix for Issue #1: Original functions are stored and restored on cleanup.
+   * Fix for Issue #7: http.get is wrapped around the original http.get,
+   * not reimplemented via mod.request + req.end().
+   */
+  async _startAsyncIOTracking() {
+    const ioThreshold = this.config.ioThreshold || 500;
+
+    const script = `
+      (function() {
+        if (globalThis.__loopDetectiveIO) {
+          return { alreadyRunning: true };
+        }
+
+        const slowOps = [];
+        const threshold = ${ioThreshold};
+        const originals = {};
+
+        function captureCallerStack() {
+          const origLimit = Error.stackTraceLimit;
+          Error.stackTraceLimit = 10;
+          const stackErr = new Error();
+          Error.stackTraceLimit = origLimit;
+          return (stackErr.stack || '').split('\\n').slice(2, 6).map(l => l.trim());
+        }
+
+        function recordSlowOp(op) {
+          slowOps.push(op);
+          if (slowOps.length > 200) slowOps.shift();
+        }
+
+        // --- Track outgoing HTTP/HTTPS requests ---
+        function patchHttp(modName) {
+          let mod;
+          try { mod = require(modName); } catch { return; }
+          const origRequest = mod.request;
+          const origGet = mod.get;
+          originals[modName + '.request'] = { mod, key: 'request', fn: origRequest };
+          originals[modName + '.get'] = { mod, key: 'get', fn: origGet };
+
+          mod.request = function patchedRequest(...args) {
+            const startTime = Date.now();
+            const opts = typeof args[0] === 'string' ? { href: args[0] } : (args[0] || {});
+            const target = opts.href || opts.hostname || opts.host || 'unknown';
+            const method = (opts.method || 'GET').toUpperCase();
+            const callerStack = captureCallerStack();
+
+            const req = origRequest.apply(this, args);
+
+            req.on('response', (res) => {
+              const duration = Date.now() - startTime;
+              if (duration >= threshold) {
+                recordSlowOp({
+                  type: 'http', protocol: modName, method, target,
+                  statusCode: res.statusCode, duration, timestamp: Date.now(), stack: callerStack,
+                });
+              }
+            });
+
+            req.on('error', (err) => {
+              const duration = Date.now() - startTime;
+              if (duration >= threshold) {
+                recordSlowOp({
+                  type: 'http', protocol: modName, method, target,
+                  error: err.message, duration, timestamp: Date.now(), stack: callerStack,
+                });
+              }
+            });
+
+            return req;
+          };
+
+          // Fix #7: Wrap original http.get instead of reimplementing
+          mod.get = function patchedGet(...args) {
+            return origGet.apply(this, args);
+          };
+          // Add timing to get as well
+          const wrappedGet = mod.get;
+          mod.get = function patchedGetWithTiming(...args) {
+            const startTime = Date.now();
+            const opts = typeof args[0] === 'string' ? { href: args[0] } : (args[0] || {});
+            const target = opts.href || opts.hostname || opts.host || 'unknown';
+            const callerStack = captureCallerStack();
+
+            const req = origGet.apply(this, args);
+
+            req.on('response', (res) => {
+              const duration = Date.now() - startTime;
+              if (duration >= threshold) {
+                recordSlowOp({
+                  type: 'http', protocol: modName, method: 'GET', target,
+                  statusCode: res.statusCode, duration, timestamp: Date.now(), stack: callerStack,
+                });
+              }
+            });
+
+            req.on('error', (err) => {
+              const duration = Date.now() - startTime;
+              if (duration >= threshold) {
+                recordSlowOp({
+                  type: 'http', protocol: modName, method: 'GET', target,
+                  error: err.message, duration, timestamp: Date.now(), stack: callerStack,
+                });
+              }
+            });
+
+            return req;
+          };
+          originals[modName + '.get'].fn = origGet;
+        }
+
+        patchHttp('http');
+        patchHttp('https');
+
+        // --- Track DNS lookups ---
+        (function patchDns() {
+          let dns;
+          try { dns = require('dns'); } catch { return; }
+          const origLookup = dns.lookup;
+          originals['dns.lookup'] = { mod: dns, key: 'lookup', fn: origLookup };
+
+          dns.lookup = function patchedLookup(hostname, options, callback) {
+            const startTime = Date.now();
+            if (typeof options === 'function') {
+              callback = options;
+              options = {};
+            }
+            const callerStack = captureCallerStack();
+
+            return origLookup.call(dns, hostname, options, function(err, address, family) {
+              const duration = Date.now() - startTime;
+              if (duration >= threshold) {
+                recordSlowOp({
+                  type: 'dns', target: hostname, duration,
+                  error: err ? err.message : null, timestamp: Date.now(), stack: callerStack,
+                });
+              }
+              if (callback) callback(err, address, family);
+            });
+          };
+        })();
+
+        // --- Track TCP socket connections ---
+        (function patchNet() {
+          let net;
+          try { net = require('net'); } catch { return; }
+          const origConnect = net.Socket.prototype.connect;
+          originals['net.Socket.connect'] = { mod: net.Socket.prototype, key: 'connect', fn: origConnect };
+
+          net.Socket.prototype.connect = function patchedConnect(...args) {
+            const startTime = Date.now();
+            const opts = typeof args[0] === 'object' ? args[0] : { port: args[0], host: args[1] };
+            const target = (opts.host || '127.0.0.1') + ':' + (opts.port || '?');
+            const callerStack = captureCallerStack();
+
+            this.once('connect', () => {
+              const duration = Date.now() - startTime;
+              if (duration >= threshold) {
+                recordSlowOp({ type: 'tcp', target, duration, timestamp: Date.now(), stack: callerStack });
+              }
+            });
+
+            this.once('error', (err) => {
+              const duration = Date.now() - startTime;
+              if (duration >= threshold) {
+                recordSlowOp({ type: 'tcp', target, error: err.message, duration, timestamp: Date.now(), stack: callerStack });
+              }
+            });
+
+            return origConnect.apply(this, args);
+          };
+        })();
+
+        globalThis.__loopDetectiveIO = {
+          getSlowOps: () => slowOps.splice(0),
+          cleanup: () => {
+            // Fix #1: Restore all original functions
+            for (const entry of Object.values(originals)) {
+              entry.mod[entry.key] = entry.fn;
+            }
+            delete globalThis.__loopDetectiveIO;
+          }
+        };
+
+        return { started: true };
+      })()
+    `;
+
+    const result = await this.inspector.send('Runtime.evaluate', {
+      expression: script,
+      returnByValue: true,
+    });
+
+    if (result.exceptionDetails) {
+      this.emit('error', new Error(`Failed to inject I/O tracker (non-fatal): ${JSON.stringify(result.exceptionDetails)}`));
+      return;
+    }
+
+    this._ioTimer = setInterval(async () => {
+      if (!this._running) return;
+      try {
+        const pollResult = await this.inspector.send('Runtime.evaluate', {
+          expression: 'globalThis.__loopDetectiveIO ? globalThis.__loopDetectiveIO.getSlowOps() : []',
+          returnByValue: true,
+        });
+        const ops = pollResult.result?.value || [];
+        for (const op of ops) {
+          this.emit('slowIO', op);
+        }
+      } catch {
+        // Inspector may have disconnected
+      }
+    }, 1000);
+  }
+
   /**
    * Take a CPU profile to identify blocking code
    */
@@ -161,17 +379,21 @@ class Detective extends EventEmitter {
   }
 
   /**
-   * Clean up the injected lag detector
+   * Clean up the injected lag detector and I/O tracker
    */
-  async _cleanupLagDetector() {
+  async _cleanupInjectedCode() {
     try {
       await this.inspector.send('Runtime.evaluate', {
         expression: 'globalThis.__loopDetective && globalThis.__loopDetective.cleanup()',
         returnByValue: true,
       });
-    } catch {
-      // Best effort cleanup
-    }
+    } catch { /* best effort */ }
+    try {
+      await this.inspector.send('Runtime.evaluate', {
+        expression: 'globalThis.__loopDetectiveIO && globalThis.__loopDetectiveIO.cleanup()',
+        returnByValue: true,
+      });
+    } catch { /* best effort */ }
   }
 
   /**
@@ -179,12 +401,11 @@ class Detective extends EventEmitter {
    */
   async start() {
     this._running = true;
+    this._stopping = false;
 
-    // Step 1: Activate inspector
     this._activateInspector();
     const port = await this._findInspectorPort();
 
-    // Step 2: Connect
     this.inspector = new Inspector({ port });
     await this.inspector.connect();
     this.emit('connected');
@@ -198,13 +419,10 @@ class Detective extends EventEmitter {
 
   async _singleRun() {
     try {
-      // Step 3: Start lag detection
       await this._startLagDetection();
+      await this._startAsyncIOTracking();
 
-      // Step 4: Capture CPU profile
       const profile = await this._captureProfile(this.config.duration);
-
-      // Step 5: Analyze
       const analysis = this.analyzer.analyzeProfile(profile);
       this.emit('profile', analysis);
     } finally {
@@ -212,28 +430,41 @@ class Detective extends EventEmitter {
     }
   }
 
+  /**
+   * Fix for Issue #2: Wrap runCycle in try/catch, emit errors,
+   * and continue the watch loop.
+   */
   async _watchMode() {
     await this._startLagDetection();
+    await this._startAsyncIOTracking();
 
     const runCycle = async () => {
       if (!this._running) return;
 
-      const profile = await this._captureProfile(this.config.duration);
-      const analysis = this.analyzer.analyzeProfile(profile);
-      this.emit('profile', analysis);
+      try {
+        const profile = await this._captureProfile(this.config.duration);
+        const analysis = this.analyzer.analyzeProfile(profile);
+        this.emit('profile', analysis);
+      } catch (err) {
+        this.emit('error', err);
+      }
 
       if (this._running) {
         setTimeout(runCycle, 1000);
       }
     };
 
-    runCycle();
+    // Await the first cycle and catch its errors
+    await runCycle();
   }
 
   /**
-   * Stop the detective and clean up
+   * Stop the detective and clean up.
+   * Fix for Issue #3: Idempotent — safe to call multiple times.
    */
   async stop() {
+    if (this._stopping) return;
+    this._stopping = true;
     this._running = false;
 
     if (this._lagTimer) {
@@ -241,8 +472,13 @@ class Detective extends EventEmitter {
       this._lagTimer = null;
     }
 
+    if (this._ioTimer) {
+      clearInterval(this._ioTimer);
+      this._ioTimer = null;
+    }
+
     if (this.inspector) {
-      await this._cleanupLagDetector();
+      await this._cleanupInjectedCode();
       await this.inspector.disconnect();
       this.inspector = null;
     }

package/src/inspector.js

@@ -64,7 +64,8 @@ class Inspector extends EventEmitter {
       this.ws.on('message', (data) => {
         const msg = JSON.parse(data.toString());
         if (msg.id !== undefined && this._callbacks.has(msg.id)) {
-          const { resolve, reject } = this._callbacks.get(msg.id);
+          const { resolve, reject, timer } = this._callbacks.get(msg.id);
+          clearTimeout(timer);
           this._callbacks.delete(msg.id);
           if (msg.error) {
             reject(new Error(msg.error.message));
@@ -98,16 +99,15 @@ class Inspector extends EventEmitter {
     const id = ++this._id;
 
     return new Promise((resolve, reject) => {
-      this._callbacks.set(id, { resolve, reject });
-      this.ws.send(JSON.stringify({ id, method, params }));
-
-      // Timeout for individual commands
-      setTimeout(() => {
+      const timer = setTimeout(() => {
         if (this._callbacks.has(id)) {
           this._callbacks.delete(id);
           reject(new Error(`CDP command timeout: ${method}`));
         }
       }, 30000);
+
+      this._callbacks.set(id, { resolve, reject, timer });
+      this.ws.send(JSON.stringify({ id, method, params }));
     });
   }
 
@@ -116,6 +116,11 @@ class Inspector extends EventEmitter {
    */
   async disconnect() {
     if (this.ws) {
+      // Clear all pending timeouts and reject pending callbacks
+      for (const { reject, timer } of this._callbacks.values()) {
+        clearTimeout(timer);
+        try { reject(new Error('Inspector disconnected')); } catch {}
+      }
       this._callbacks.clear();
       this.ws.close();
       this.ws = null;

package/src/reporter.js

@@ -20,6 +20,7 @@ class Reporter {
   constructor(config) {
     this.config = config;
     this.lagEvents = [];
+    this.slowIOEvents = [];
   }
 
   onConnected() {
@@ -40,10 +41,29 @@ class Reporter {
     }
   }
 
+  onSlowIO(data) {
+    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'
+      ? `${data.method} ${data.target} → ${data.statusCode || data.error || '?'}`
+      : data.type === 'dns'
+      ? `lookup ${data.target}${data.error ? ' (' + data.error + ')' : ''}`
+      : `connect ${data.target}${data.error ? ' (' + data.error + ')' : ''}`;
+    this._print(`${severity}${icon} Slow ${data.type.toUpperCase()}: ${data.duration}ms${COLORS.reset} ${detail}`);
+    if (data.stack && data.stack.length > 0) {
+      for (const line of data.stack.slice(0, 3)) {
+        this._print(`  ${COLORS.dim}  ${line}${COLORS.reset}`);
+      }
+    }
+  }
+
   onProfile(analysis) {
     if (this.config.json) {
-      this._print(JSON.stringify({ ...analysis, lagEvents: this.lagEvents }, null, 2));
+      this._print(JSON.stringify({ ...analysis, lagEvents: this.lagEvents, slowIOEvents: this.slowIOEvents }, null, 2));
       this.lagEvents = [];
+      this.slowIOEvents = [];
       return;
     }
 
@@ -51,9 +71,11 @@ class Reporter {
     this._printPatterns(analysis.blockingPatterns);
     this._printHeavyFunctions(analysis.heavyFunctions);
     this._printCallStacks(analysis.callStacks);
+    this._printSlowIOSummary();
     this._printLagSummary();
 
     this.lagEvents = [];
+    this.slowIOEvents = [];
   }
 
   onError(err) {
@@ -138,6 +160,53 @@ class Reporter {
     }
   }
 
+  _printSlowIOSummary() {
+    if (this.slowIOEvents.length === 0) {
+      this._print(`\n  ${COLORS.green}✔ No slow I/O operations detected${COLORS.reset}`);
+      return;
+    }
+
+    this._print(`\n  ${COLORS.magenta}⚠ Slow Async I/O Summary${COLORS.reset}`);
+    this._print(`    Total slow ops: ${this.slowIOEvents.length}`);
+
+    // Group by type
+    const byType = {};
+    for (const op of this.slowIOEvents) {
+      if (!byType[op.type]) byType[op.type] = [];
+      byType[op.type].push(op);
+    }
+
+    for (const [type, ops] of Object.entries(byType)) {
+      const icon = type === 'http' ? '🌐' : 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`);
+
+      // Group by target
+      const byTarget = {};
+      for (const op of ops) {
+        const key = op.type === 'http' ? `${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;
+        byTarget[key].maxDuration = Math.max(byTarget[key].maxDuration, op.duration);
+        if (op.error) byTarget[key].errors++;
+      }
+
+      const sorted = Object.entries(byTarget).sort((a, b) => b[1].totalDuration - a[1].totalDuration);
+      for (const [target, stats] of sorted.slice(0, 5)) {
+        const errStr = stats.errors > 0 ? ` ${COLORS.red}(${stats.errors} errors)${COLORS.reset}` : '';
+        this._print(`      ${COLORS.yellow}${target}${COLORS.reset}${errStr}`);
+        this._print(`        ${stats.count} calls, total ${stats.totalDuration}ms, avg ${Math.round(stats.totalDuration / stats.count)}ms, max ${stats.maxDuration}ms`);
+        if (stats.stack && stats.stack.length > 0) {
+          for (const line of stats.stack.slice(0, 2)) {
+            this._print(`        ${COLORS.dim}${line}${COLORS.reset}`);
+          }
+        }
+      }
+    }
+  }
+
   _printLagSummary() {
     if (this.lagEvents.length === 0) {
       this._print(`\n  ${COLORS.green}✔ No event loop lag detected above threshold${COLORS.reset}`);