Harden Nostr startup performance

js/devReqMonitor.js

@@ -1,69 +1,104 @@
-// Dev-only relay REQ-rate monitor.
+// Local-only relay REQ-rate monitor.
 //
-// Patches WebSocket.send to count outgoing Nostr REQ frames and, every 2s,
-// console.warns when the rate exceeds a threshold — naming the storming filter
-// kinds. This runs inside the real browser session against real relays/lists,
-// which the headless harness cannot fully reproduce. It is purely observational
-// and only activates on localhost (or when `localStorage.__bitvidReqMonitor__`
-// is set), so production is unaffected.
-//
-// Remove this import from index.js once the login-perf work is done.
+// It patches WebSocket.send for a real-session relay-storm investigation, so
+// normal localhost development must opt in explicitly. Public deployments can
+// never enable it, even if a storage key is present.
 
-(function installReqMonitor() {
-  if (typeof window === "undefined" || typeof WebSocket === "undefined") return;
+export const REQUEST_MONITOR_STORAGE_KEY = "__bitvidReqMonitor__";
 
-  const enabled =
-    location.hostname === "localhost" ||
-    location.hostname === "127.0.0.1" ||
-    (() => {
-      try {
-        return localStorage.getItem("__bitvidReqMonitor__") === "1";
-      } catch {
-        return false;
-      }
-    })();
-  if (!enabled || window.__bitvidReqMonitorInstalled) return;
-  window.__bitvidReqMonitorInstalled = true;
+const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
+const THRESHOLD = 15;
+const WINDOW_MS = 2000;
+
+function readStorage(storage) {
+  try {
+    return storage?.getItem?.(REQUEST_MONITOR_STORAGE_KEY) ?? null;
+  } catch (_) {
+    return null;
+  }
+}
+
+export function isRequestMonitorEnabled({ locationRef, storage } = {}) {
+  const hostname = typeof locationRef?.hostname === "string"
+    ? locationRef.hostname.toLowerCase()
+    : "";
+  return LOCAL_HOSTS.has(hostname) && readStorage(storage) === "1";
+}
+
+export function installRequestMonitor({
+  scope = typeof window !== "undefined" ? window : null,
+  locationRef = scope?.location,
+  storage = scope?.localStorage,
+  WebSocketClass = scope?.WebSocket,
+  setIntervalFn = scope?.setInterval?.bind(scope),
+  clearIntervalFn = scope?.clearInterval?.bind(scope),
+  logger = scope?.console || console,
+} = {}) {
+  if (
+    !scope ||
+    !WebSocketClass?.prototype ||
+    typeof WebSocketClass.prototype.send !== "function" ||
+    typeof setIntervalFn !== "function" ||
+    !isRequestMonitorEnabled({ locationRef, storage })
+  ) {
+    return null;
+  }
+  if (scope.__bitvidReqMonitorInstalled) {
+    return scope.__bitvidReqMonitorInstalled;
+  }
 
-  const THRESHOLD = 15; // REQ/s above this is a storm worth reporting
-  const WINDOW_MS = 2000;
   let windowReqs = 0;
   const byKind = new Map();
+  const originalSend = WebSocketClass.prototype.send;
 
-  const origSend = WebSocket.prototype.send;
-  WebSocket.prototype.send = function (data) {
+  WebSocketClass.prototype.send = function monitoredSend(data) {
     try {
       if (typeof data === "string" && data.startsWith('["REQ"')) {
         windowReqs += 1;
-        const msg = JSON.parse(data);
-        for (const f of msg.slice(2)) {
-          const k = Array.isArray(f?.kinds) ? `kind ${f.kinds.join("/")}` : "kind ?";
-          byKind.set(k, (byKind.get(k) || 0) + 1);
+        const message = JSON.parse(data);
+        for (const filter of message.slice(2)) {
+          const kind = Array.isArray(filter?.kinds)
+            ? `kind ${filter.kinds.join("/")}`
+            : "kind ?";
+          byKind.set(kind, (byKind.get(kind) || 0) + 1);
         }
       }
-    } catch {
-      /* ignore */
+    } catch (_) {
+      // Diagnostics must never affect a WebSocket send.
     }
-    return origSend.apply(this, arguments);
+    return originalSend.apply(this, arguments);
   };
 
-  setInterval(() => {
-    const perSec = (windowReqs / WINDOW_MS) * 1000;
-    if (perSec >= THRESHOLD) {
+  const intervalId = setIntervalFn(() => {
+    const perSecond = (windowReqs / WINDOW_MS) * 1000;
+    if (perSecond >= THRESHOLD) {
       const top = [...byKind.entries()]
         .sort((a, b) => b[1] - a[1])
         .slice(0, 6)
-        .map(([k, n]) => `${k}=${n}`)
+        .map(([kind, count]) => `${kind}=${count}`)
         .join(", ");
-      // eslint-disable-next-line no-console
-      console.warn(
-        `[req-monitor] RELAY STORM ${perSec.toFixed(0)} REQ/s over ${WINDOW_MS / 1000}s → ${top}`,
+      logger?.warn?.(
+        `[req-monitor] RELAY STORM ${perSecond.toFixed(0)} REQ/s over ${WINDOW_MS / 1000}s → ${top}`,
       );
     }
     windowReqs = 0;
     byKind.clear();
   }, WINDOW_MS);
 
-  // eslint-disable-next-line no-console
-  console.info("[req-monitor] active — will warn if relay REQ rate spikes.");
-})();
+  const monitor = {
+    stop() {
+      WebSocketClass.prototype.send = originalSend;
+      if (typeof clearIntervalFn === "function") {
+        clearIntervalFn(intervalId);
+      }
+      if (scope.__bitvidReqMonitorInstalled === monitor) {
+        delete scope.__bitvidReqMonitorInstalled;
+      }
+    },
+  };
+  scope.__bitvidReqMonitorInstalled = monitor;
+  logger?.info?.("[req-monitor] active — will warn if relay REQ rate spikes.");
+  return monitor;
+}
+
+installRequestMonitor();