@agent-native/core 0.85.7 → 0.86.1

package/dist/client/session-replay.js

@@ -52,6 +52,10 @@ const MAX_CONSOLE_ARGS = 10;
 const MAX_CONSOLE_STACK_LENGTH = 2000;
 const MAX_CONSOLE_SERIALIZE_DEPTH = 4;
 const MAX_CONSOLE_SERIALIZE_ENTRIES = 20;
+/** Default cap (chars) for a captured 5xx response-body snippet. */
+const DEFAULT_MAX_ERROR_BODY_LENGTH = 2048;
+/** Hard timeout for the async response-body read; emit without body past this. */
+const ERROR_BODY_READ_TIMEOUT_MS = 1500;
 /**
  * Re-entrancy guard: true while the recorder itself is emitting custom events
  * or flushing (synchronously) so the console/fetch/XHR wrappers never capture
@@ -361,7 +365,9 @@ function normalizeOptions(options) {
 }
 /**
  * Console/network capture default to ON whenever session replay records;
- * `false` disables a category, an object form overrides its caps.
+ * `false` disables a category, an object form overrides its caps. Network
+ * options may additionally carry `captureErrorBodies`/`maxErrorBodyLength`;
+ * console ignores those fields.
  */
 function normalizeCaptureToggle(value, defaultMaxEvents) {
     if (value === false)
@@ -371,7 +377,15 @@ function normalizeCaptureToggle(value, defaultMaxEvents) {
         Number.isFinite(overrides.maxEvents)
         ? Math.max(1, Math.floor(overrides.maxEvents))
         : defaultMaxEvents;
-    return { maxEvents };
+    const maxErrorBodyLength = typeof overrides.maxErrorBodyLength === "number" &&
+        Number.isFinite(overrides.maxErrorBodyLength)
+        ? Math.max(0, Math.floor(overrides.maxErrorBodyLength))
+        : DEFAULT_MAX_ERROR_BODY_LENGTH;
+    return {
+        maxEvents,
+        captureErrorBodies: overrides.captureErrorBodies !== false,
+        maxErrorBodyLength,
+    };
 }
 function scrubStringValue(key, value) {
     const lowerKey = key.toLowerCase();
@@ -1098,6 +1112,34 @@ function isCaptureExcludedUrl(rawUrl, ingestEndpoint) {
     }
     return false;
 }
+/**
+ * Best-effort, synchronous read of a 5xx XHR response body, sliced to `cap`
+ * before redaction runs (caller redacts). Only reads `responseText` when
+ * `responseType` is "" or "text" -- other response types are read via
+ * `JSON.stringify` (guarded) for `"json"`, and skipped entirely otherwise
+ * since arbitrary binary/blob/arraybuffer bodies are not useful error text.
+ */
+function readXhrErrorBody(xhr, cap) {
+    try {
+        const responseType = xhr.responseType;
+        if (responseType === "" || responseType === "text") {
+            const text = xhr.responseText;
+            return typeof text === "string" ? text.slice(0, cap) : undefined;
+        }
+        if (responseType === "json") {
+            try {
+                return JSON.stringify(xhr.response)?.slice(0, cap);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function installNetworkCapture(state, captureOptions) {
     const options = state.options;
     if (!options)
@@ -1119,7 +1161,10 @@ function installNetworkCapture(state, captureOptions) {
         emitted += 1;
         emitReplayCustomEvent(state, SESSION_REPLAY_NETWORK_EVENT_TAG, payload);
     };
-    const recordRequest = (api, method, rawUrl, status, ok, durationMs, error) => {
+    const errorBodyCap = captureOptions.captureErrorBodies !== false
+        ? (captureOptions.maxErrorBodyLength ?? DEFAULT_MAX_ERROR_BODY_LENGTH)
+        : null;
+    const recordRequest = (api, method, rawUrl, status, ok, durationMs, error, responseBody) => {
         if (stopped)
             return;
         try {
@@ -1139,12 +1184,55 @@ function installNetworkCapture(state, captureOptions) {
                         error: truncateCaptureText(redactCaptureText(error), MAX_CONSOLE_MESSAGE_LENGTH),
                     }
                     : {}),
+                ...(responseBody
+                    ? {
+                        responseBody: truncateCaptureText(redactCaptureText(responseBody), errorBodyCap ?? DEFAULT_MAX_ERROR_BODY_LENGTH),
+                    }
+                    : {}),
             });
         }
         catch {
             // capture must never break the host page
         }
     };
+    /**
+     * Best-effort bounded read of a 5xx response body. Reads a decoded stream
+     * up to `cap` chars and cancels the reader, or falls back to `.text()`
+     * sliced to `cap` when no readable stream is exposed. Never throws --
+     * opaque/no-body responses (or any read failure) resolve to undefined.
+     */
+    const readBoundedErrorBody = async (response, cap) => {
+        try {
+            const reader = response.body?.getReader?.();
+            if (reader) {
+                const decoder = new TextDecoder();
+                let text = "";
+                while (text.length < cap) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    if (value)
+                        text += decoder.decode(value, { stream: true });
+                }
+                // Fire-and-forget: cancelling an already-exhausted (or still-open but
+                // no-longer-wanted) reader can hang indefinitely on some stream
+                // implementations. We never need the result, so don't await it --
+                // that would defeat the whole point of bounding this read.
+                try {
+                    reader.cancel().catch(() => { });
+                }
+                catch {
+                    // best-effort; some readers throw synchronously instead
+                }
+                return text.slice(0, cap);
+            }
+            const text = await response.text();
+            return text.slice(0, cap);
+        }
+        catch {
+            return undefined;
+        }
+    };
     const restores = [];
     if (typeof window.fetch === "function") {
         const originalFetch = window.fetch;
@@ -1168,15 +1256,49 @@ function installNetworkCapture(state, captureOptions) {
                 return originalFetch.call(self, input, init);
             }
             const startedAt = performance.now();
-            // Call the original exactly as the page did; never read bodies, never
-            // replace the response, propagate rejections untouched.
+            // Call the original exactly as the page did; never read the caller's
+            // response before returning it, never replace the response, propagate
+            // rejections untouched. A 5xx body snippet (if any) is read from a
+            // clone and emitted from a detached promise chain afterward.
             const result = originalFetch.call(self, input, init);
             if (!result || typeof result.then !== "function") {
                 return result;
             }
             return result.then((response) => {
                 try {
-                    recordRequest("fetch", method, url, response.status, response.ok, performance.now() - startedAt);
+                    const durationMs = performance.now() - startedAt;
+                    if (errorBodyCap !== null && response.status >= 500) {
+                        // Clone immediately -- before any other code (including this
+                        // handler returning) can consume the original body -- so the
+                        // clone's stream is guaranteed unconsumed.
+                        let clone = null;
+                        try {
+                            clone = response.clone();
+                        }
+                        catch {
+                            clone = null;
+                        }
+                        if (clone) {
+                            const bodyPromise = readBoundedErrorBody(clone, errorBodyCap);
+                            const timeoutPromise = new Promise((resolve) => {
+                                setTimeout(() => resolve(undefined), ERROR_BODY_READ_TIMEOUT_MS);
+                            });
+                            // Detached chain: never rejects, never awaited by the caller.
+                            Promise.race([bodyPromise, timeoutPromise])
+                                .then((responseBody) => {
+                                recordRequest("fetch", method, url, response.status, response.ok, durationMs, undefined, responseBody);
+                            })
+                                .catch(() => {
+                                // never affect the caller
+                            });
+                        }
+                        else {
+                            recordRequest("fetch", method, url, response.status, response.ok, durationMs);
+                        }
+                    }
+                    else {
+                        recordRequest("fetch", method, url, response.status, response.ok, durationMs);
+                    }
                 }
                 catch {
                     // never affect the caller
@@ -1231,7 +1353,12 @@ function installNetworkCapture(state, captureOptions) {
                     this.addEventListener("timeout", markError("XMLHttpRequest timed out"), { once: true });
                     this.addEventListener("loadend", () => {
                         const status = typeof this.status === "number" ? this.status : 0;
-                        recordRequest("xhr", info.method, info.url, errorMessage ? 0 : status, !errorMessage && status >= 200 && status < 300, performance.now() - startedAt, errorMessage);
+                        const effectiveStatus = errorMessage ? 0 : status;
+                        let responseBody;
+                        if (errorBodyCap !== null && !errorMessage && status >= 500) {
+                            responseBody = readXhrErrorBody(this, errorBodyCap);
+                        }
+                        recordRequest("xhr", info.method, info.url, effectiveStatus, !errorMessage && status >= 200 && status < 300, performance.now() - startedAt, errorMessage, responseBody);
                         xhrInfo.delete(this);
                     }, { once: true });
                 }