@replayio-app-building/netlify-recorder 0.47.0 → 0.49.0

package/dist/index.d.ts

@@ -331,6 +331,10 @@ interface EnsureRequestRecordingOptions {
  *    with the blob data URL from the stored request, updates the row to `"queued"`,
  *    and returns `null`.
  *
+ * For warm-start requests, registers all preceding requests from the same
+ * module instance with the recorder service before triggering the recording,
+ * so the recorder can replay them to reconstruct module-level state.
+ *
  * This function is idempotent — calling it multiple times for the same request
  * is safe. Once the recording completes, subsequent calls return the recording ID.
  */

package/dist/index.js

@@ -32,6 +32,9 @@ function incrementCallIndex() {
 }
 
 // src/interceptors/network.ts
+import http from "http";
+import https from "https";
+import { Readable, Writable } from "stream";
 function isNeonQuery(obj) {
   return typeof obj === "object" && obj !== null && "query" in obj && "params" in obj;
 }
@@ -52,6 +55,159 @@ function buildSetConfigQueries(requestId, callIndex) {
     { query: "SELECT set_config('app.replay_call_index', $1, true)", params: [String(callIndex)] }
   ];
 }
+function patchHttpModules(mode, calls, consumed) {
+  const origHttpRequest = http.request;
+  const origHttpsRequest = https.request;
+  function makeInterceptedRequest(mod, origRequest, protocol, args) {
+    let options;
+    let callback;
+    if (typeof args[0] === "string" || args[0] instanceof URL) {
+      const urlStr2 = typeof args[0] === "string" ? args[0] : args[0].href;
+      options = typeof args[1] === "object" && args[1] !== null ? { ...args[1] } : {};
+      try {
+        const parsed = new URL(urlStr2);
+        options.hostname = options.hostname ?? parsed.hostname;
+        options.port = options.port ?? parsed.port;
+        options.path = options.path ?? parsed.pathname + parsed.search;
+        options.protocol = options.protocol ?? parsed.protocol;
+      } catch {
+        options.path = options.path ?? urlStr2;
+      }
+      callback = typeof args[2] === "function" ? args[2] : void 0;
+      if (!callback && typeof args[1] === "function") {
+        callback = args[1];
+      }
+    } else {
+      options = typeof args[0] === "object" && args[0] !== null ? { ...args[0] } : {};
+      callback = typeof args[1] === "function" ? args[1] : void 0;
+    }
+    const host = options.hostname || options.host || "localhost";
+    const port = options.port ? `:${options.port}` : "";
+    const path = options.path || "/";
+    const urlStr = `${protocol}//${host}${port}${path}`;
+    const method = (options.method || "GET").toUpperCase();
+    if (mode === "replay") {
+      return replayHttpRequest(urlStr, method, calls, consumed, callback);
+    }
+    const req = origRequest.call(mod, ...args);
+    const bodyChunks = [];
+    const origWrite = req.write.bind(req);
+    const origEnd = req.end.bind(req);
+    req.write = function(chunk, ...rest) {
+      if (chunk) bodyChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      return origWrite(chunk, ...rest);
+    };
+    req.end = function(chunk, ...rest) {
+      if (chunk && typeof chunk !== "function") bodyChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      return origEnd(chunk, ...rest);
+    };
+    const startTime = Date.now();
+    req.on("response", (res) => {
+      const resChunks = [];
+      res.on("data", (chunk) => resChunks.push(chunk));
+      res.on("end", () => {
+        const endTime = Date.now();
+        const requestHeaders = {};
+        if (options.headers) {
+          for (const [k, v] of Object.entries(options.headers)) {
+            if (v !== void 0) requestHeaders[k] = Array.isArray(v) ? v.join(", ") : String(v);
+          }
+        }
+        const responseHeaders = {};
+        if (res.headers) {
+          for (const [k, v] of Object.entries(res.headers)) {
+            if (v !== void 0) responseHeaders[k] = Array.isArray(v) ? v.join(", ") : String(v);
+          }
+        }
+        const store = getRequestStore();
+        const targetCalls = store?.networkCalls ?? calls;
+        targetCalls.push({
+          url: urlStr,
+          method,
+          requestHeaders,
+          requestBody: bodyChunks.length > 0 ? Buffer.concat(bodyChunks).toString("utf-8") : void 0,
+          responseStatus: res.statusCode ?? 0,
+          responseHeaders,
+          responseBody: Buffer.concat(resChunks).toString("utf-8"),
+          timestamp: endTime,
+          startTime,
+          endTime
+        });
+      });
+    });
+    return req;
+  }
+  http.request = function(...args) {
+    return makeInterceptedRequest(http, origHttpRequest, "http:", args);
+  };
+  https.request = function(...args) {
+    return makeInterceptedRequest(https, origHttpsRequest, "https:", args);
+  };
+  return () => {
+    http.request = origHttpRequest;
+    https.request = origHttpsRequest;
+  };
+}
+function replayHttpRequest(url, _method, calls, consumed, callback) {
+  let matchIdx = -1;
+  for (let i = 0; i < calls.length; i++) {
+    if (consumed.has(i)) continue;
+    const c = calls[i];
+    if (c && c.url === url) {
+      matchIdx = i;
+      break;
+    }
+  }
+  if (matchIdx === -1) {
+    for (let i = 0; i < calls.length; i++) {
+      if (!consumed.has(i)) {
+        matchIdx = i;
+        break;
+      }
+    }
+  }
+  const call = calls[matchIdx];
+  if (matchIdx === -1 || !call) {
+    throw new Error(
+      `No more recorded network calls to replay for http/https request (exhausted ${calls.length} calls)`
+    );
+  }
+  consumed.add(matchIdx);
+  const duration = call.endTime - call.startTime;
+  console.log(
+    `  [network-replay] Consumed call ${consumed.size}/${calls.length}: ${call.method} ${call.url} => ${call.responseStatus} (original: ${duration}ms)`
+  );
+  const body = call.responseBody ?? "";
+  const fakeRes = new Readable({
+    read() {
+      this.push(body);
+      this.push(null);
+    }
+  });
+  fakeRes.statusCode = call.responseStatus;
+  fakeRes.statusMessage = "";
+  fakeRes.headers = {};
+  if (call.responseHeaders) {
+    for (const [k, v] of Object.entries(call.responseHeaders)) {
+      fakeRes.headers[k.toLowerCase()] = v;
+    }
+  }
+  const fakeReq = new Writable({
+    write(_chunk, _encoding, cb) {
+      cb();
+    },
+    final(cb) {
+      cb();
+    }
+  });
+  fakeReq.aborted = false;
+  fakeReq.reusedSocket = false;
+  process.nextTick(() => {
+    if (callback) callback(fakeRes);
+    fakeReq.emit("response", fakeRes);
+  });
+  return fakeReq;
+}
 var _realOriginalFetch = null;
 var _captureInterceptorInstalled = false;
 function ensureCaptureInterceptor() {
@@ -117,10 +273,12 @@ function installNetworkInterceptor(mode, calls) {
     if (store) {
       ensureCaptureInterceptor();
       store.networkCalls = calls;
+      const restoreHttp3 = patchHttpModules("capture", calls, null);
       return {
         restore() {
           const s = getRequestStore();
           if (s) s.networkCalls = null;
+          restoreHttp3();
         },
         consumedCount() {
           return 0;
@@ -181,9 +339,11 @@ function installNetworkInterceptor(mode, calls) {
       return response;
     };
     globalThis.fetch = captureFetch;
+    const restoreHttp2 = patchHttpModules("capture", calls, null);
     return {
       restore() {
         globalThis.fetch = originalFetch2;
+        restoreHttp2();
       },
       consumedCount() {
         return 0;
@@ -260,9 +420,11 @@ function installNetworkInterceptor(mode, calls) {
     };
   };
   globalThis.fetch = replayFetch;
+  const restoreHttp = patchHttpModules("replay", calls, consumed);
   return {
     restore() {
       globalThis.fetch = originalFetch;
+      restoreHttp();
     },
     consumedCount() {
       return consumed.size;
@@ -1425,6 +1587,19 @@ function remoteCallbacks(recorderUrl) {
     }
   };
 }
+async function backendRequestsListPreceding(sql, targetRequestId, originalRequestId) {
+  const rows = await sql`
+    SELECT id, blob_data_url, handler_path, commit_sha, branch_name, repository_url,
+           original_request_id, status, recording_id, error_message, created_at, updated_at
+    FROM backend_requests
+    WHERE original_request_id = ${originalRequestId}
+      AND id != ${targetRequestId}
+      AND created_at <= (SELECT created_at FROM backend_requests WHERE id = ${targetRequestId})
+      AND blob_data_url IS NOT NULL
+    ORDER BY created_at ASC
+  `;
+  return rows;
+}
 async function ensureRequestRecording(sql, requestId, options) {
   const request = await backendRequestsGet(sql, requestId);
   if (!request) {
@@ -1437,6 +1612,30 @@ async function ensureRequestRecording(sql, requestId, options) {
     return null;
   }
   const recorderUrl = options.recorderUrl.replace(/\/+$/, "");
+  const origReqId = request.original_request_id;
+  if (origReqId && origReqId !== requestId) {
+    const preceding = await backendRequestsListPreceding(sql, requestId, origReqId);
+    if (preceding.length > 0) {
+      await Promise.all(
+        preceding.map(
+          (req) => fetch(`${recorderUrl}/api/store-request`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              requestId: req.id,
+              blobDataUrl: req.blob_data_url,
+              handlerPath: req.handler_path,
+              commitSha: req.commit_sha,
+              branchName: req.branch_name,
+              repositoryUrl: req.repository_url ?? void 0,
+              originalRequestId: req.original_request_id ?? void 0
+            })
+          }).catch(() => {
+          })
+        )
+      );
+    }
+  }
   const res = await fetch(`${recorderUrl}/api/create-recording`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -1448,7 +1647,7 @@ async function ensureRequestRecording(sql, requestId, options) {
       branchName: request.branch_name,
       repositoryUrl: request.repository_url ?? void 0,
       webhookUrl: options.webhookUrl,
-      originalRequestId: request.original_request_id ?? void 0
+      originalRequestId: origReqId ?? void 0
     })
   });
   if (!res.ok) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@replayio-app-building/netlify-recorder",
-  "version": "0.47.0",
+  "version": "0.49.0",
   "description": "Capture and replay Netlify function executions as Replay recordings",
   "type": "module",
   "exports": {