fboxrec 0.1.0 → 0.3.0

package/README.md

@@ -32,6 +32,10 @@ Everything is correlated by request via AsyncLocalStorage, timestamped with
 the monotonic clock, and held in a fixed 64MB ring (configurable) — the
 recorded window is a consequence of memory and traffic, not a setting.
 
+`flightbox.stop()` disarms recording and restores the patched modules
+(console, http server/client, fetch, pg) to their originals, so tests and
+clean shutdowns leave no trace; `start()` can be called again afterwards.
+
 ## When something breaks
 
 Triggers snapshot the ring into a gzipped `.fbox` incident file:

package/dist/{chunk-HCJF2ASP.mjs → chunk-4DHWBXXW.mjs}

@@ -653,7 +653,7 @@ var FORMAT_VERSION = 1;
 var MAX_DECOMPRESSED_BYTES = 1024 * 1024 * 1024;
 
 // src/dump/serializer.ts
-var FLIGHTBOX_VERSION = "0.1.0";
+var FLIGHTBOX_VERSION = "0.3.0";
 var DUMP_GZIP_LEVEL = 1;
 var dumpCounter = 0;
 function buildIncident(opts) {
@@ -1444,8 +1444,9 @@ function startWatchdog(agent) {
 // src/instrumentations/http-server.ts
 import * as http from "http";
 import { createHash as createHash2, timingSafeEqual } from "crypto";
-var patched = false;
 var agentRef;
+var active2 = false;
+var saved = null;
 function tokenMatches(supplied, expected) {
   const a = createHash2("sha256").update(supplied).digest();
   const b = createHash2("sha256").update(expected).digest();
@@ -1487,12 +1488,12 @@ function handleFlightboxEndpoint(agent, req, res) {
 }
 function instrumentHttpServer(agent) {
   agentRef = agent;
-  if (patched) return;
-  patched = true;
+  active2 = true;
+  if (saved) return;
   const orig = http.Server.prototype.emit;
   const flightboxEmit = function(event) {
     const args = arguments;
-    if (event !== "request") {
+    if (!active2 || event !== "request") {
       return orig.apply(this, args);
     }
     const agent2 = agentRef;
@@ -1545,13 +1546,22 @@ function instrumentHttpServer(agent) {
     }
     return requestStorage.run(ctx, () => orig.apply(this, args));
   };
-  http.Server.prototype.emit = flightboxEmit;
+  saved = { orig, wrapper: flightboxEmit };
+  http.Server.prototype.emit = saved.wrapper;
+}
+function restoreHttpServer() {
+  active2 = false;
+  if (saved && http.Server.prototype.emit === saved.wrapper) {
+    http.Server.prototype.emit = saved.orig;
+    saved = null;
+  }
 }
 
 // src/instrumentations/http-client.ts
 import { createRequire } from "module";
-var patched2 = false;
 var agentRef2;
+var active3 = false;
+var liveWraps = /* @__PURE__ */ new Map();
 function extractTarget(args) {
   let method = "GET";
   let host = "";
@@ -1583,10 +1593,12 @@ function extractTarget(args) {
   return { method: String(method).toUpperCase(), host: String(host), path: String(path8) };
 }
 var nodeRequire = createRequire(process.cwd() + "/noop.js");
-function wrapModule(mod) {
-  const origRequest = mod.request.bind(mod);
+function wrapModule(key, mod) {
+  const rawRequest = mod.request;
+  const rawGet = mod.get;
+  const origRequest = rawRequest.bind(mod);
   const tracedRequest = function(...args) {
-    if (isShedding()) return origRequest(...args);
+    if (!active3 || isShedding()) return origRequest(...args);
     const agent = agentRef2;
     let spanId = 0n;
     let requestId = 0n;
@@ -1633,18 +1645,27 @@ function wrapModule(mod) {
     }
     return req;
   };
-  mod.request = tracedRequest;
-  mod.get = function(...args) {
+  const tracedGet = function(...args) {
     const req = tracedRequest(...args);
     req.end();
     return req;
   };
+  mod.request = tracedRequest;
+  mod.get = tracedGet;
+  liveWraps.set(key, () => {
+    let clear = true;
+    if (mod.request === tracedRequest) mod.request = rawRequest;
+    else clear = false;
+    if (mod.get === tracedGet) mod.get = rawGet;
+    else clear = false;
+    return clear;
+  });
 }
 function wrapFetch() {
   const origFetch = globalThis.fetch;
   if (typeof origFetch !== "function") return;
-  globalThis.fetch = async function flightboxFetch(input, init) {
-    if (isShedding()) return origFetch(input, init);
+  const wrapper = async function flightboxFetch(input, init) {
+    if (!active3 || isShedding()) return origFetch(input, init);
     const agent = agentRef2;
     let spanId = 0n;
     let requestId = 0n;
@@ -1697,22 +1718,41 @@ function wrapFetch() {
       throw err;
     }
   };
+  globalThis.fetch = wrapper;
+  liveWraps.set("fetch", () => {
+    if (globalThis.fetch === wrapper) {
+      globalThis.fetch = origFetch;
+      return true;
+    }
+    return false;
+  });
 }
 function instrumentHttpClient(agent) {
   agentRef2 = agent;
-  if (patched2) return;
-  patched2 = true;
-  try {
-    wrapModule(nodeRequire("node:http"));
-  } catch {
+  active3 = true;
+  if (!liveWraps.has("http")) {
+    try {
+      wrapModule("http", nodeRequire("node:http"));
+    } catch {
+    }
   }
-  try {
-    wrapModule(nodeRequire("node:https"));
-  } catch {
+  if (!liveWraps.has("https")) {
+    try {
+      wrapModule("https", nodeRequire("node:https"));
+    } catch {
+    }
   }
-  try {
-    wrapFetch();
-  } catch {
+  if (!liveWraps.has("fetch")) {
+    try {
+      wrapFetch();
+    } catch {
+    }
+  }
+}
+function restoreHttpClient() {
+  active3 = false;
+  for (const [key, undo] of liveWraps) {
+    if (undo()) liveWraps.delete(key);
   }
 }
 
@@ -1732,17 +1772,21 @@ function paramShapes(values) {
   return values.slice(0, 32).map((v) => v === null ? "null" : Array.isArray(v) ? "array" : typeof v);
 }
 var agentRef3;
+var active4 = false;
+var queryPatch = null;
+var connectPatch = null;
 function instrumentPg(agent) {
   agentRef3 = agent;
   const recorder = {
     record: ((...args) => agentRef3.recorder.record(...args))
   };
+  active4 = true;
   const pg = loadPg();
   if (!pg?.Client?.prototype?.query) return false;
-  if (!pg.Client.prototype.query.__flightbox) {
+  if (!queryPatch && !pg.Client.prototype.query.__flightbox) {
     const origQuery = pg.Client.prototype.query;
     const wrappedQuery = function(...args) {
-      if (isShedding()) return origQuery.apply(this, args);
+      if (!active4 || isShedding()) return origQuery.apply(this, args);
       let spanId = 0n;
       let requestId = 0n;
       let tStart = 0n;
@@ -1815,13 +1859,14 @@ function instrumentPg(agent) {
       return out;
     };
     wrappedQuery.__flightbox = true;
+    queryPatch = { proto: pg.Client.prototype, orig: origQuery, wrapper: wrappedQuery };
     pg.Client.prototype.query = wrappedQuery;
   }
   const Pool = pg.Pool;
-  if (Pool?.prototype?.connect && !Pool.prototype.connect.__flightbox) {
+  if (Pool?.prototype?.connect && !connectPatch && !Pool.prototype.connect.__flightbox) {
     const origConnect = Pool.prototype.connect;
     const wrappedConnect = function(cb) {
-      if (isShedding()) return origConnect.call(this, cb);
+      if (!active4 || isShedding()) return origConnect.call(this, cb);
       const tStart = nowMono();
       const requestId = currentRequestId();
       const record = () => {
@@ -1848,33 +1893,58 @@ function instrumentPg(agent) {
       return out;
     };
     wrappedConnect.__flightbox = true;
+    connectPatch = { proto: Pool.prototype, orig: origConnect, wrapper: wrappedConnect };
     Pool.prototype.connect = wrappedConnect;
   }
   return true;
 }
+function restorePg() {
+  active4 = false;
+  if (queryPatch && queryPatch.proto.query === queryPatch.wrapper) {
+    queryPatch.proto.query = queryPatch.orig;
+    queryPatch = null;
+  }
+  if (connectPatch && connectPatch.proto.connect === connectPatch.wrapper) {
+    connectPatch.proto.connect = connectPatch.orig;
+    connectPatch = null;
+  }
+}
 
 // src/instrumentations/console.ts
 import { formatWithOptions } from "util";
 var LEVELS = ["log", "info", "warn", "error", "debug"];
 var FORMAT_OPTS = { depth: 2, maxArrayLength: 20, maxStringLength: LIMITS.log };
-var patched3 = false;
 var agentRef4;
+var active5 = false;
+var patches = /* @__PURE__ */ new Map();
 function instrumentConsole(agent) {
   agentRef4 = agent;
-  if (patched3) return;
-  patched3 = true;
+  active5 = true;
   for (const level of LEVELS) {
-    const orig = console[level].bind(console);
-    console[level] = function flightboxConsole(...args) {
+    if (patches.has(level)) continue;
+    const orig = console[level];
+    const bound = orig.bind(console);
+    const wrapper = function flightboxConsole(...args) {
       try {
-        if (!isShedding()) {
+        if (active5 && !isShedding()) {
           const msg = capScrub(formatWithOptions(FORMAT_OPTS, ...args), LIMITS.log);
           agentRef4.recorder.record(8 /* Log */, { level, msg });
         }
       } catch {
       }
-      orig(...args);
+      bound(...args);
     };
+    patches.set(level, { orig, wrapper });
+    console[level] = wrapper;
+  }
+}
+function restoreConsole() {
+  active5 = false;
+  for (const [level, p] of patches) {
+    if (console[level] === p.wrapper) {
+      console[level] = p.orig;
+      patches.delete(level);
+    }
   }
 }
 
@@ -1896,6 +1966,21 @@ function applyInstrumentations(agent) {
     }
   }
 }
+var RESTORATIONS = [
+  ["http-server", restoreHttpServer],
+  ["http-client", restoreHttpClient],
+  ["pg", restorePg],
+  ["console", restoreConsole]
+];
+function removeInstrumentations(log) {
+  for (const [name, restore] of RESTORATIONS) {
+    try {
+      restore();
+    } catch (err) {
+      log(`instrumentation ${name} failed to restore: ${err.message}`);
+    }
+  }
+}
 
 // src/instrumentations/vitals.ts
 import { monitorEventLoopDelay } from "perf_hooks";
@@ -2177,6 +2262,7 @@ function stop() {
       } catch {
       }
     }
+    removeInstrumentations(instance.config.log);
     instance.panicWriter.disarm();
     setShedding(false);
     instance = null;
@@ -2191,4 +2277,4 @@ export {
   stop,
   index_default
 };
-//# sourceMappingURL=chunk-HCJF2ASP.mjs.map
+//# sourceMappingURL=chunk-4DHWBXXW.mjs.map