noibu-react-native 0.2.34-rc.1 → 0.2.34-rc.3

package/dist/constants.js

@@ -24,7 +24,7 @@ const CONTENT_TYPE = 'content-type';
  * Gets the script id from the cookie object, returns default if cannot be found
  */
 function GET_SCRIPT_ID() {
-    return "1.0.104-rn-sdk-0.2.34-rc.1" ;
+    return "1.0.104-rn-sdk-0.2.34-rc.3" ;
 }
 /**
  * Gets the max metro recon number

package/dist/entry/init.js

@@ -76,17 +76,23 @@ function globalInit(customerConfig) {
             const clickMonitor = ClickMonitor.getInstance();
             const pageMonitor = PageMonitor.getInstance();
             AppNavigationMonitor.getInstance().monitor();
-            // Only initialize HTTP data collection and request monitoring if enabled
-            if (ClientConfig.getInstance().enableHttpDataCollection) {
-                HTTPDataBundler.getInstance();
-                RequestMonitor.getInstance().monitor();
-            }
-            // monitoring calls
+            // monitoring calls - each wrapped independently so one failure doesn't affect others
             ErrorMonitor.getInstance().monitor();
             clickMonitor.monitor();
             keyboardInputMonitor.monitor();
             pageMonitor.monitor();
             SessionRecorder.getInstance().recordUserSession();
+            // Initialize HTTP data collection and request monitoring if enabled
+            // This is done after other monitors so failures here don't affect session recording
+            if (ClientConfig.getInstance().enableHttpDataCollection) {
+                try {
+                    HTTPDataBundler.getInstance();
+                    RequestMonitor.getInstance().monitor();
+                }
+                catch (error) {
+                    ClientConfig.getInstance().postInternalError({ msg: `Error initializing HTTP data collection`, error }, false, Severity.ERROR);
+                }
+            }
             if (metroplexSocket.connectionPromise) {
                 metroplexSocket.connectionPromise.catch((error) => ClientConfig.getInstance().postInternalError({ msg: `Error during metroplexSocket initial connection`, error }, false, Severity.ERROR));
             }

package/dist/monitors/ErrorMonitor.js

@@ -1,4 +1,4 @@
-import { asString, isStackTrace } from '../utils/function.js';
+import { isStackTrace, asString } from '../utils/function.js';
 import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
 import { replace } from '../utils/object.js';
 import { Singleton } from './BaseMonitor.js';

package/dist/monitors/RequestMonitor.d.ts

@@ -3,14 +3,12 @@ import { Monitor, Singleton } from './BaseMonitor';
 export default class RequestMonitor extends Singleton implements Monitor {
     /** main method */
     monitor(): void;
-    /**
-     * Gets a response text Promise out of Response & headers. Returns reason if bundler decides to drop text.
-     * Due to async nature of text() and async function sent to Promise.all,
-     * our code race competes with client's code consuming the response.
-     * So at this point engine somehow gets access to the original ReadableStream and marks it as locked,
-     * thus client code may throw an error.
-     */
-    private static consumeResponseAndGetBodyText;
+    /** Decodes an ArrayBuffer into UTF-8 text. */
+    private static decodeArrayBufferToText;
+    /** Reads the response body once and returns both raw body and decoded text. */
+    private static readResponseBody;
+    /** Creates a fresh Response for the customer, preserving metadata. */
+    private static buildCustomerResponse;
     /** Generates new PVEventHTTP */
     private static getPvEventHttp;
     /** Gets headers from request or request options. Handles different scenarios where simple conversion is not possible */
@@ -24,10 +22,8 @@ export default class RequestMonitor extends Singleton implements Monitor {
     private static getRequestBody;
     /** Returns the parameters to pass the HttpEventManager constructor. Specific to the fetch wrapper. */
     private static getHttpDataFromFetch;
-    /** Clones Response / Request or returns original object if cloning is not possible */
-    private static cloneResponse;
     /** Handles fetch response safely. Reports HttpEventManager and error to Pagevisit if needed. */
-    private static safeHandleFetchResponse;
+    private static handleFetchResponse;
     /** Safe function to get method and url from fetch args */
     private static getMethodUrlFromFetchArgs;
     /**

package/dist/monitors/RequestMonitor.js

@@ -5,7 +5,6 @@ import { safeEntries, propWriteableOrMadeWriteable, replace } from '../utils/obj
 import ClientConfig from '../api/ClientConfig.js';
 import { noibuLog } from '../utils/log.js';
 import { tryGetStackTrace, safeTrim } from '../utils/function.js';
-import { promiseAll } from '../utils/polyfills.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
 import { HTTPDataBundler } from './http-tools/HTTPDataBundler.js';
 import GqlErrorValidator from './http-tools/GqlErrorValidator.js';
@@ -23,24 +22,100 @@ class RequestMonitor extends Singleton {
         RequestMonitor.setupGlobalXMLHttpWrapper();
         noibuLog('monitorRequests ended');
     }
-    /**
-     * Gets a response text Promise out of Response & headers. Returns reason if bundler decides to drop text.
-     * Due to async nature of text() and async function sent to Promise.all,
-     * our code race competes with client's code consuming the response.
-     * So at this point engine somehow gets access to the original ReadableStream and marks it as locked,
-     * thus client code may throw an error.
-     */
-    static consumeResponseAndGetBodyText(response) {
+    /** Decodes an ArrayBuffer into UTF-8 text. */
+    static decodeArrayBufferToText(buffer) {
+        try {
+            if (typeof TextDecoder !== 'undefined') {
+                return new TextDecoder('utf-8').decode(buffer);
+            }
+        }
+        catch (_a) {
+            // ignore and fall back to manual decode
+        }
+        const bytes = new Uint8Array(buffer);
+        const chunkSize = 0x8000;
+        let result = '';
+        for (let i = 0; i < bytes.length; i += chunkSize) {
+            const chunk = bytes.subarray(i, i + chunkSize);
+            result += String.fromCharCode.apply(null, Array.from(chunk));
+        }
+        return result;
+    }
+    /** Reads the response body once and returns both raw body and decoded text. */
+    static readResponseBody(response) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!(response instanceof Response)) {
-                return '';
+                return null;
+            }
+            const tryRead = (target) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const buffer = yield target.arrayBuffer();
+                    return { body: buffer, text: RequestMonitor.decodeArrayBufferToText(buffer) };
+                }
+                catch (_a) {
+                    // Fall back to text() if arrayBuffer() is unsupported or fails
+                    try {
+                        const text = yield target.text();
+                        return { body: text, text };
+                    }
+                    catch (_b) {
+                        return null;
+                    }
+                }
+            });
+            // Prefer reading from a clone to avoid mutating the original Response.
+            try {
+                if (!response.bodyUsed && typeof response.clone === 'function') {
+                    const clone = response.clone();
+                    const clonedResult = yield tryRead(clone);
+                    if (clonedResult) {
+                        return clonedResult;
+                    }
+                }
+            }
+            catch (_a) {
+                // ignore and fall back to reading the original response
             }
             if (response.bodyUsed) {
-                return BODY_USED_ERROR;
+                return null;
             }
-            return response.text();
+            return tryRead(response);
         });
     }
+    /** Creates a fresh Response for the customer, preserving metadata. */
+    static buildCustomerResponse(ogResponse, body) {
+        try {
+            const headers = new Headers(ogResponse.headers);
+            const customerResponse = new Response(body, {
+                status: ogResponse.status,
+                statusText: ogResponse.statusText,
+                headers,
+            });
+            // Best-effort copy of read-only metadata (works in some polyfills).
+            try {
+                Object.defineProperty(customerResponse, 'url', { value: ogResponse.url, configurable: true });
+            }
+            catch (_a) {
+                // ignore
+            }
+            try {
+                Object.defineProperty(customerResponse, 'redirected', { value: ogResponse.redirected, configurable: true });
+            }
+            catch (_b) {
+                // ignore
+            }
+            try {
+                Object.defineProperty(customerResponse, 'type', { value: ogResponse.type, configurable: true });
+            }
+            catch (_c) {
+                // ignore
+            }
+            return customerResponse;
+        }
+        catch (_d) {
+            return ogResponse;
+        }
+    }
     /** Generates new PVEventHTTP */
     static getPvEventHttp(status, responseHeaders, method, url, responseTime) {
         const httpEvent = {
@@ -87,16 +162,9 @@ class RequestMonitor extends Singleton {
             return HTTPDataBundler.getInstance().bundleHTTPData(url, RequestMonitor.getRequestHeaders(request, options), RequestMonitor.getRequestBody(requestText, options), RequestMonitor.getResponseHeaders(response), responseText, method, isError);
         });
     }
-    /** Clones Response / Request or returns original object if cloning is not possible */
-    static cloneResponse(ogResponse) {
-        if (!ogResponse.bodyUsed) {
-            return ogResponse.clone();
-        }
-        return ogResponse; // body consumed already, no http response body for us
-    }
     /** Handles fetch response safely. Reports HttpEventManager and error to Pagevisit if needed. */
-    static safeHandleFetchResponse(startTime, url, method, options, request) {
-        return (ogResponse) => __awaiter(this, void 0, void 0, function* () {
+    static handleFetchResponse(startTime, url, method, options, request, ogResponse, responseText, shouldCaptureBody, shouldCheckGql) {
+        return __awaiter(this, void 0, void 0, function* () {
             var _a;
             try {
                 if (!ogResponse) {
@@ -104,31 +172,26 @@ class RequestMonitor extends Singleton {
                     // logging to track the issue if it becomes widespread
                     return ClientConfig.getInstance().postInternalError({ msg: 'No response object in fetch callback', url, method, options, request }, false, Severity.ERROR);
                 }
-                const clonedResponse = RequestMonitor.cloneResponse(ogResponse); // have to do it as early as possible
-                const graphqlResponse = RequestMonitor.cloneResponse(clonedResponse); // and two times more for each consumption
-                const httpEventDataResponse = RequestMonitor.cloneResponse(clonedResponse);
+                // Read metadata directly from ogResponse (sync, does not consume body)
                 const respTime = Date.now() - startTime;
-                const status = clonedResponse.status;
-                const headers = clonedResponse.headers;
-                const gqlError = yield GqlErrorValidator.fromFetch(url, options, request, graphqlResponse);
+                const status = ogResponse.status;
+                const headers = ogResponse.headers;
+                const gqlError = shouldCheckGql && responseText
+                    ? yield GqlErrorValidator.fromFetchResponseText(url, options, request, status, responseText)
+                    : null;
                 const isHttpError = isHttpCodeFailure(status);
-                // Only consume request/response bodies if HTTP data collection is enabled for this URL
-                // This prevents bodyUsed from being set to true when customers don't want body capture
-                const shouldCaptureBody = HTTPDataBundler.getInstance().shouldContinueForURL(url);
-                const [maybeRequestText, responseText] = shouldCaptureBody
-                    ? yield promiseAll([
-                        Promise.resolve((_a = request === null || request === void 0 ? void 0 : request.text) === null || _a === void 0 ? void 0 : _a.call(request)),
-                        RequestMonitor.consumeResponseAndGetBodyText(httpEventDataResponse),
-                    ])
-                    : [undefined, undefined];
+                const maybeRequestText = shouldCaptureBody ? yield Promise.resolve((_a = request === null || request === void 0 ? void 0 : request.text) === null || _a === void 0 ? void 0 : _a.call(request)) : undefined;
+                const responseTextForHttp = shouldCaptureBody
+                    ? responseText !== null && responseText !== void 0 ? responseText : BODY_USED_ERROR
+                    : undefined;
                 const httpEvent = RequestMonitor.getPvEventHttp(status, headers, method, url, respTime);
                 const httpData = shouldCaptureBody
-                    ? yield RequestMonitor.getHttpDataFromFetch(request, httpEventDataResponse, method, url, options, isHttpError || !!gqlError, maybeRequestText, responseText)
+                    ? yield RequestMonitor.getHttpDataFromFetch(request, ogResponse, method, url, options, isHttpError || !!gqlError, maybeRequestText, responseTextForHttp)
                     : null;
                 const seq = saveHTTPEvent(httpEvent, httpData, !!gqlError);
                 if (isHttpError) {
                     // this does not consume response body so no need to clone it
-                    saveErrorToPagevisit(Object.assign(Object.assign({}, clonedResponse), { type: PageVisitErrorSource.Response }), seq);
+                    saveErrorToPagevisit(Object.assign(Object.assign({}, ogResponse), { type: PageVisitErrorSource.Response }), seq);
                 }
                 if (gqlError) {
                     gqlError.forEach(error => saveErrorToPagevisit({
@@ -193,12 +256,33 @@ class RequestMonitor extends Singleton {
                 }
                 const startTime = Date.now();
                 const promiseFromOriginalFetch = originalFunction.call(this, resource, options);
-                promiseFromOriginalFetch
-                    .then(RequestMonitor.safeHandleFetchResponse(startTime, url, method, options, request))
-                    .catch(err => {
+                /**
+                 * Return a promise that resolves with a response safe for the customer.
+                 * When HTTP collection or GQL validation need the response body, we read it
+                 * once and rebuild a fresh Response to avoid mutating the customer's bodyUsed.
+                 */
+                const customerPromise = promiseFromOriginalFetch.then((ogResponse) => __awaiter(this, void 0, void 0, function* () {
+                    const shouldCheckGql = GqlErrorValidator.shouldCheckRequest(url, options, request);
+                    const shouldCaptureBody = HTTPDataBundler.getInstance().shouldContinueForURL(url);
+                    const shouldReadBody = shouldCaptureBody || shouldCheckGql;
+                    let customerResponse = ogResponse;
+                    let responseText;
+                    if (shouldReadBody) {
+                        const buffered = yield RequestMonitor.readResponseBody(ogResponse);
+                        if (buffered) {
+                            responseText = buffered.text;
+                            customerResponse = RequestMonitor.buildCustomerResponse(ogResponse, buffered.body);
+                        }
+                    }
+                    RequestMonitor.handleFetchResponse(startTime, url, method, options, request, ogResponse, responseText, shouldCaptureBody, shouldCheckGql).catch(() => {
+                        // errors are handled inside handleFetchResponse
+                    });
+                    return customerResponse;
+                }));
+                customerPromise.catch(err => {
                     RequestMonitor.handleFetchFailure(err, url);
                 });
-                return promiseFromOriginalFetch;
+                return customerPromise;
             };
         });
     }

package/dist/monitors/http-tools/GqlErrorValidator.d.ts

@@ -1,6 +1,10 @@
 import { GQLError } from 'noibu-metroplex-ts-bindings';
 /** Try detecting GraphQL errors from http response */
 export default class GqlErrorValidator {
+    /** Determines if a request should be checked for GQL errors. */
+    static shouldCheckRequest(url: string, options?: RequestInit, request?: Request): boolean;
+    /** Retrieves GQL error object based on response body text */
+    static fromFetchResponseText(url: string, options: RequestInit | undefined, request: Request | undefined, status: number, responseText: string | null | undefined): Promise<GQLError[] | null>;
     /** Retrieves GQL error object based on fetch request/response */
     static fromFetch(url: string, options: RequestInit | undefined, request: Request | undefined, response: Response): Promise<GQLError[] | null>;
     /** Retrieves GQL error object based on XHR object */

package/dist/monitors/http-tools/GqlErrorValidator.js

@@ -15,11 +15,43 @@ const MESSAGE_MAX_LENGTH = 1000;
 /* eslint-disable no-param-reassign */
 /** Try detecting GraphQL errors from http response */
 class GqlErrorValidator {
+    /** Determines if a request should be checked for GQL errors. */
+    static shouldCheckRequest(url, options, request) {
+        const contentType = this._getContentTypeFromFetchArguments(options, request);
+        return this._shouldHandleRequest(url, contentType);
+    }
+    /** Retrieves GQL error object based on response body text */
+    static fromFetchResponseText(url, options, request, status, responseText) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!responseText) {
+                    return null;
+                }
+                const isResponseValid = status >= 200 && status <= 299;
+                if (!isResponseValid) {
+                    return null;
+                }
+                const contentType = this._getContentTypeFromFetchArguments(options, request);
+                if (this._shouldHandleRequest(url, contentType)) {
+                    const data = this._parseJsonSafely(responseText);
+                    if (data) {
+                        return this._validate(data, []);
+                    }
+                }
+            }
+            catch (e) {
+                if (!this._isRequestAborted(options, request)) {
+                    this._postError(e);
+                }
+            }
+            return null;
+        });
+    }
     /** Retrieves GQL error object based on fetch request/response */
     static fromFetch(url, options, request, response) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const isResponseValid = isInstanceOf(response, Response) && response.ok;
+                const isResponseValid = isInstanceOf(response, Response) && response.ok && !response.bodyUsed;
                 if (!isResponseValid) {
                     return null;
                 }

package/dist/sessionRecorder/SessionRecorder.js

@@ -11,8 +11,6 @@ import { Severity, MetroplexMessageType } from 'noibu-metroplex-ts-bindings';
 
 // custom event name for posting metrics
 const POST_METRICS_EVENT_NAME = 'noibuPostMetrics';
-// the max amount of time to wait for user events until freezing rrweb mutation events
-const MAX_TIME_FOR_RECORDER_USER_EVENTS = 2000;
 // Maximum number of events in the RRWEB session recorder buffer
 // before sending to Metroplex
 const MAX_RECORDER_EVENT_BUFFER = 10;
@@ -105,22 +103,13 @@ class SessionRecorder extends Singleton {
                 this.freeze();
                 return;
             }
-            // determine if timeout should be extended based on event/source type
-            // event type 3 is an incremental snapshot
-            // event data source 0 is a mutation (all other data sources are user events)
+            // Note: Automatic freeze timeout is disabled for React Native.
+            // The native SDK handles its own event throttling/batching.
+            // Freezing is still triggered by closeIfInactive() and didCutVideo checks above.
             if (this.pauseTimeout) {
-                // received a user event, extend the timeout
                 clearTimeout(this.pauseTimeout);
                 this.freezingEvents = false;
             }
-            this.pauseTimeout = setTimeout(() => {
-                // stop recording page mutations after 2s of inactivity
-                // otherwise sites with many mutations will hit max video size
-                // in a short amount of time without any user events
-                this.freezingEvents = true;
-                // freezePage stops emitting events until the next user event is received
-                this.freeze();
-            }, MAX_TIME_FOR_RECORDER_USER_EVENTS);
             // Set the first recorded timestamp if it hasn't been set yet.
             // We usually only want this to be set once as the first recorded timestamp
             // should not change.

package/dist/sessionRecorder/nativeSessionRecorderSubscription.js

@@ -86,7 +86,6 @@ function subscribeToNativeEvent(callback) {
                     try {
                         const batch = yield NativeSessionRecorder.consumeEvents();
                         if (Array.isArray(batch) && batch.length > 0) {
-                            noibuLog("Actual batch: ", batch);
                             for (const message of batch) {
                                 try {
                                     const _a = JSON.parse(message), { data } = _a, rest = __rest(_a, ["data"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noibu-react-native",
-  "version": "0.2.34-rc.1",
+  "version": "0.2.34-rc.3",
   "targetNjsVersion": "1.0.104",
   "description": "React-Native SDK for NoibuJS to collect errors in React-Native applications",
   "main": "dist/entry/index.js",

package/dist/utils/polyfills.js

@@ -1,24 +0,0 @@
-var _a, _b;
-/**
- * In case Promise.all is not available, use this polyfill
- */
-const promiseAll = ((_b = (_a = Promise === null || Promise === void 0 ? void 0 : Promise.all) === null || _a === void 0 ? void 0 : _a.bind) === null || _b === void 0 ? void 0 : _b.call(_a, Promise)) ||
-    ((values) => {
-        return new Promise(function (resolve, reject) {
-            const result = [];
-            let total = 0;
-            values.forEach((item, index) => {
-                Promise.resolve(item)
-                    .then(res => {
-                    result[index] = res;
-                    total += 1;
-                    if (total === values.length) {
-                        resolve(result);
-                    }
-                })
-                    .catch(reject);
-            });
-        });
-    });
-
-export { promiseAll };