@multiplayer-app/session-recorder-browser 1.2.8 → 1.2.10

package/dist/browser/index.js

@@ -25245,7 +25245,7 @@ const DEFAULT_MAX_HTTP_CAPTURING_PAYLOAD_SIZE = 100000;
 const SESSION_RESPONSE = 'multiplayer-debug-session-response';
 const CONTINUOUS_DEBUGGING_TIMEOUT = 60000; // 1 minutes
 const DEBUG_SESSION_MAX_DURATION_SECONDS = 10 * 60 + 30; // TODO: move to shared config otel core
-const PACKAGE_VERSION_EXPORT = "1.2.8" || 0;
+const PACKAGE_VERSION_EXPORT = "1.2.10" || 0;
 // Regex patterns for OpenTelemetry ignore URLs
 const OTEL_IGNORE_URLS = [
     // Traces endpoint
@@ -25952,13 +25952,11 @@ class TracerBrowserSDK {
                                     return;
                                 }
                                 // @ts-ignore
-                                const requestBody = xhr.networkRequest.requestBody;
-                                // @ts-ignore
-                                const responseBody = xhr.networkRequest.responseBody;
-                                // @ts-ignore
-                                const requestHeaders = xhr.networkRequest.requestHeaders || {};
-                                // @ts-ignore
-                                const responseHeaders = xhr.networkRequest.responseHeaders || {};
+                                const networkRequest = xhr.networkRequest;
+                                const requestBody = networkRequest.requestBody;
+                                const responseBody = networkRequest.responseBody;
+                                const requestHeaders = networkRequest.requestHeaders || {};
+                                const responseHeaders = networkRequest.responseHeaders || {};
                                 const payload = {
                                     requestBody,
                                     responseBody,
@@ -25988,12 +25986,28 @@ class TracerBrowserSDK {
                                 if (!captureBody && !captureHeaders) {
                                     return;
                                 }
-                                const requestBody = request.body;
-                                const requestHeaders = (0,_helpers__WEBPACK_IMPORTED_MODULE_3__.headersToObject)(request.headers);
-                                const responseHeaders = (0,_helpers__WEBPACK_IMPORTED_MODULE_3__.headersToObject)(response instanceof Response ? response.headers : undefined);
+                                // Try to get data from our fetch wrapper first
+                                // @ts-ignore
+                                const networkRequest = response === null || response === void 0 ? void 0 : response.networkRequest;
+                                let requestBody = null;
                                 let responseBody = null;
-                                if (response instanceof Response && response.body) {
-                                    responseBody = await (0,_helpers__WEBPACK_IMPORTED_MODULE_3__.extractResponseBody)(response);
+                                let requestHeaders = {};
+                                let responseHeaders = {};
+                                if (networkRequest) {
+                                    // Use data captured by our fetch wrapper
+                                    requestBody = networkRequest.requestBody;
+                                    responseBody = networkRequest.responseBody;
+                                    requestHeaders = networkRequest.requestHeaders || {};
+                                    responseHeaders = networkRequest.responseHeaders || {};
+                                }
+                                else {
+                                    // Fallback to original OpenTelemetry approach
+                                    requestBody = request.body;
+                                    requestHeaders = (0,_helpers__WEBPACK_IMPORTED_MODULE_3__.headersToObject)(request.headers);
+                                    responseHeaders = (0,_helpers__WEBPACK_IMPORTED_MODULE_3__.headersToObject)(response instanceof Response ? response.headers : undefined);
+                                    if (response instanceof Response && response.body) {
+                                        responseBody = await (0,_helpers__WEBPACK_IMPORTED_MODULE_3__.extractResponseBody)(response);
+                                    }
                                 }
                                 const payload = {
                                     requestBody,
@@ -26060,6 +26074,156 @@ class TracerBrowserSDK {
 }
 
 
+/***/ }),
+
+/***/ "./src/patch/fetch.ts":
+/*!****************************!*\
+  !*** ./src/patch/fetch.ts ***!
+  \****************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   setMaxCapturingHttpPayloadSize: () => (/* binding */ setMaxCapturingHttpPayloadSize),
+/* harmony export */   setShouldRecordHttpData: () => (/* binding */ setShouldRecordHttpData)
+/* harmony export */ });
+/* harmony import */ var _utils_type_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/type-utils */ "./src/utils/type-utils.ts");
+/* harmony import */ var _utils_request_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils/request-utils */ "./src/utils/request-utils.ts");
+/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../config */ "./src/config/index.ts");
+
+
+
+let recordRequestHeaders = true;
+let recordResponseHeaders = true;
+const shouldRecordBody = true;
+let maxCapturingHttpPayloadSize = _config__WEBPACK_IMPORTED_MODULE_2__.DEFAULT_MAX_HTTP_CAPTURING_PAYLOAD_SIZE;
+const setMaxCapturingHttpPayloadSize = (_maxCapturingHttpPayloadSize) => {
+    maxCapturingHttpPayloadSize = _maxCapturingHttpPayloadSize;
+};
+const setShouldRecordHttpData = (shouldRecordBody, shouldRecordHeaders) => {
+    recordRequestHeaders = shouldRecordHeaders;
+    recordResponseHeaders = shouldRecordHeaders;
+    // eslint-disable-next-line
+    shouldRecordBody = shouldRecordBody;
+};
+function _tryReadFetchBody({ body, url, }) {
+    if ((0,_utils_type_utils__WEBPACK_IMPORTED_MODULE_0__.isNullish)(body)) {
+        return null;
+    }
+    if ((0,_utils_type_utils__WEBPACK_IMPORTED_MODULE_0__.isString)(body)) {
+        return body;
+    }
+    if ((0,_utils_type_utils__WEBPACK_IMPORTED_MODULE_0__.isDocument)(body)) {
+        return body.textContent;
+    }
+    if ((0,_utils_type_utils__WEBPACK_IMPORTED_MODULE_0__.isFormData)(body)) {
+        return (0,_utils_request_utils__WEBPACK_IMPORTED_MODULE_1__.formDataToQuery)(body);
+    }
+    if ((0,_utils_type_utils__WEBPACK_IMPORTED_MODULE_0__.isObject)(body)) {
+        try {
+            return JSON.stringify(body);
+        }
+        catch (_a) {
+            return '[Fetch] Failed to stringify request object';
+        }
+    }
+    return `[Fetch] Cannot read body of type ${toString.call(body)}`;
+}
+async function _tryReadResponseBody(response) {
+    var _a, _b;
+    try {
+        // Clone the response to avoid consuming the original stream
+        const clonedResponse = response.clone();
+        // Try different methods to read the body
+        if ((_a = response.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.includes('application/json')) {
+            const json = await clonedResponse.json();
+            return JSON.stringify(json);
+        }
+        else if ((_b = response.headers.get('content-type')) === null || _b === void 0 ? void 0 : _b.includes('text/')) {
+            return await clonedResponse.text();
+        }
+        else {
+            // For other content types, try text first, fallback to arrayBuffer
+            try {
+                return await clonedResponse.text();
+            }
+            catch (_c) {
+                try {
+                    const arrayBuffer = await clonedResponse.arrayBuffer();
+                    return `[Fetch] Binary data (${arrayBuffer.byteLength} bytes)`;
+                }
+                catch (_d) {
+                    return '[Fetch] Unable to read response body';
+                }
+            }
+        }
+    }
+    catch (error) {
+        return `[Fetch] Error reading response body: ${error instanceof Error ? error.message : 'Unknown error'}`;
+    }
+}
+function _headersToObject(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+}
+// Store original fetch
+const originalFetch = window.fetch;
+// Override fetch
+window.fetch = async function (input, init) {
+    const networkRequest = {};
+    // Capture request data
+    const request = new Request(input, init);
+    if (recordRequestHeaders) {
+        networkRequest.requestHeaders = _headersToObject(request.headers);
+    }
+    if (shouldRecordBody && request.body) {
+        const requestBody = _tryReadFetchBody({
+            body: request.body,
+            url: request.url
+        });
+        if ((requestBody === null || requestBody === void 0 ? void 0 : requestBody.length) &&
+            new Blob([requestBody]).size <= maxCapturingHttpPayloadSize) {
+            networkRequest.requestBody = requestBody;
+        }
+    }
+    try {
+        // Make the actual fetch request
+        const response = await originalFetch(input, init);
+        // Capture response data
+        if (recordResponseHeaders) {
+            networkRequest.responseHeaders = _headersToObject(response.headers);
+        }
+        if (shouldRecordBody) {
+            const responseBody = await _tryReadResponseBody(response);
+            if ((responseBody === null || responseBody === void 0 ? void 0 : responseBody.length) &&
+                new Blob([responseBody]).size <= maxCapturingHttpPayloadSize) {
+                networkRequest.responseBody = responseBody;
+            }
+        }
+        // Attach network request data to the response for later access
+        // @ts-ignore
+        response.networkRequest = networkRequest;
+        return response;
+    }
+    catch (error) {
+        // Even if the fetch fails, we can still capture the request data
+        // @ts-ignore
+        const errorResponse = new Response(null, { status: 0, statusText: 'Network Error' });
+        // @ts-ignore
+        errorResponse.networkRequest = networkRequest;
+        throw error;
+    }
+};
+// Preserve the original fetch function's properties
+Object.setPrototypeOf(window.fetch, originalFetch);
+Object.defineProperty(window.fetch, 'name', { value: 'fetch' });
+Object.defineProperty(window.fetch, 'length', { value: originalFetch.length });
+
+
 /***/ }),
 
 /***/ "./src/patch/index.ts":
@@ -26071,6 +26235,8 @@ class TracerBrowserSDK {
 "use strict";
 __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _xhr__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./xhr */ "./src/patch/xhr.ts");
+/* harmony import */ var _fetch__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./fetch */ "./src/patch/fetch.ts");
+