noibu-react-native 0.2.2 → 0.2.3

package/dist/sessionRecorder/sessionRecorder.js

@@ -1,3 +1,4 @@
+import { __awaiter } from 'tslib';
 import { strToU8, zlibSync, strFromU8 } from 'fflate';
 import { LogLevel, initialize, subscribeToNativeEvent } from './nativeSessionRecorderSubscription.js';
 import StoredMetrics from '../api/storedMetrics.js';
@@ -10,21 +11,11 @@ import { noibuLog } from '../utils/log.js';
 
 /** Singleton class to record user sessions */
 class SessionRecorder {
-    static instance;
-    eventBuffer;
-    vfCounter;
-    didSetupRecorder;
-    isVideoLengthNegativeInvalid;
-    lastFragPostTimestamp;
-    pauseTimeout;
-    lastRecordedTimestamp;
-    firstRecordedTimestamp;
-    recordStopper;
-    freezingEvents = false;
     /**
      * Creates an instance of the session recorder
      */
     constructor() {
+        this.freezingEvents = false;
         this.eventBuffer = [];
         this.vfCounter = 0;
         this.didSetupRecorder = false;
@@ -94,21 +85,23 @@ class SessionRecorder {
     /**
      * Starts recording the user session
      */
-    async recordUserSession() {
-        // check if inactive before starting any recording
-        noibuLog('recordUserSession');
-        if ((await MetroplexSocket.getInstance().closeIfInactive()) ||
-            StoredMetrics.getInstance().didCutVideo) {
-            return;
-        }
-        // making sure we are not attempting to call this method
-        // multiple times.
-        if (this.didSetupRecorder) {
-            return;
-        }
-        StoredMetrics.getInstance().setDidStartVideo();
-        this.recordStopper = subscribeToNativeEvent(this.handleRecorderEvent.bind(this));
-        this.didSetupRecorder = true;
+    recordUserSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // check if inactive before starting any recording
+            noibuLog('recordUserSession');
+            if ((yield MetroplexSocket.getInstance().closeIfInactive()) ||
+                StoredMetrics.getInstance().didCutVideo) {
+                return;
+            }
+            // making sure we are not attempting to call this method
+            // multiple times.
+            if (this.didSetupRecorder) {
+                return;
+            }
+            StoredMetrics.getInstance().setDidStartVideo();
+            this.recordStopper = subscribeToNativeEvent(this.handleRecorderEvent.bind(this));
+            this.didSetupRecorder = true;
+        });
     }
     /**
      * handleNewRRwebEvent will process each upcoming.
@@ -116,71 +109,75 @@ class SessionRecorder {
      * is updated with the latest events and post the contents
      * of the buffer if it exceeds max size
      */
-    async handleRecorderEvent(recorderEvent) {
-        const timestamp = Date.now();
-        // check if inactive before any processing
-        if ((await MetroplexSocket.getInstance().closeIfInactive()) ||
-            StoredMetrics.getInstance().didCutVideo) {
-            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)
-        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.
-        if (!this.firstRecordedTimestamp) {
-            this.firstRecordedTimestamp = timestamp;
-        }
-        // Set the last recorded timestamp if it hasn't been set yet or a newly received rrweb
-        // event has a more recent timestamp than the last recorded timestamp.
-        if (!this.lastRecordedTimestamp || timestamp > this.lastRecordedTimestamp) {
-            this.lastRecordedTimestamp = timestamp;
-        }
-        // Checks if we've gone back in time for some reason.
-        // If we have, adjust our data accordingly to ensure we don't mess up
-        // the metrics 'exp_vid_len' data.
-        // If we don't adjust for time, we assume that the expected video length is
-        // the difference between the first recorded timestamp and the last recorded timestamp.
-        if (this.firstRecordedTimestamp &&
-            timestamp < this.firstRecordedTimestamp) {
-            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Detected time rewind. Client has been disabled.`, true, SEVERITY.error, true);
-            return;
-        }
-        const packedEvent = await this.pack(recorderEvent.message);
-        // Buffer the event for sending to metroplex
-        this.eventBuffer.push(packedEvent);
-        // Check if the event was a click or a double click. This is true if the root type is
-        // incremental snapshot (3) and the data source is mouse interaction data (2).
-        // Finally, we capture a click (2) or double click (4) event.
-        // todo if there are clicks, call StoredMetrics.getInstance().addVideoClick(); for each click
-        const now = Date.now();
-        const delta = now - this.lastFragPostTimestamp;
-        if (this.eventBuffer.length >= MAX_RECORDER_EVENT_BUFFER ||
-            delta > MAX_TIME_FOR_UNSENT_DATA_MILLIS) {
-            this.handleFragPost();
-        }
+    handleRecorderEvent(recorderEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const timestamp = Date.now();
+            // check if inactive before any processing
+            if ((yield MetroplexSocket.getInstance().closeIfInactive()) ||
+                StoredMetrics.getInstance().didCutVideo) {
+                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)
+            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.
+            if (!this.firstRecordedTimestamp) {
+                this.firstRecordedTimestamp = timestamp;
+            }
+            // Set the last recorded timestamp if it hasn't been set yet or a newly received rrweb
+            // event has a more recent timestamp than the last recorded timestamp.
+            if (!this.lastRecordedTimestamp || timestamp > this.lastRecordedTimestamp) {
+                this.lastRecordedTimestamp = timestamp;
+            }
+            // Checks if we've gone back in time for some reason.
+            // If we have, adjust our data accordingly to ensure we don't mess up
+            // the metrics 'exp_vid_len' data.
+            // If we don't adjust for time, we assume that the expected video length is
+            // the difference between the first recorded timestamp and the last recorded timestamp.
+            if (this.firstRecordedTimestamp &&
+                timestamp < this.firstRecordedTimestamp) {
+                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Detected time rewind. Client has been disabled.`, true, SEVERITY.error, true);
+                return;
+            }
+            const packedEvent = yield this.pack(recorderEvent.message);
+            // Buffer the event for sending to metroplex
+            this.eventBuffer.push(packedEvent);
+            // Check if the event was a click or a double click. This is true if the root type is
+            // incremental snapshot (3) and the data source is mouse interaction data (2).
+            // Finally, we capture a click (2) or double click (4) event.
+            // todo if there are clicks, call StoredMetrics.getInstance().addVideoClick(); for each click
+            const now = Date.now();
+            const delta = now - this.lastFragPostTimestamp;
+            if (this.eventBuffer.length >= MAX_RECORDER_EVENT_BUFFER ||
+                delta > MAX_TIME_FOR_UNSENT_DATA_MILLIS) {
+                this.handleFragPost();
+            }
+        });
     }
     /**
      * Compress event
      */
-    async pack(recorderEvent) {
-        // return JSON.stringify(recorderEvent);
-        return SessionRecorder.compress(recorderEvent);
+    pack(recorderEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // return JSON.stringify(recorderEvent);
+            return SessionRecorder.compress(recorderEvent);
+        });
     }
     static compress(snapshot) {
         const uncompressedString = stringifyJSON(snapshot);
@@ -200,76 +197,80 @@ class SessionRecorder {
      * necessary management of the buffer and it's related
      * variables
      */
-    async handleFragPost() {
-        // check if inactive before any processing
-        if (await MetroplexSocket.getInstance().closeIfInactive()) {
-            return;
-        }
-        if (!this.didSetupRecorder) {
-            return;
-        }
-        if (this.eventBuffer.length === 0) {
-            return;
-        }
-        try {
-            let totalVideoTime = 0;
-            // checking if we have those values set in the first place
-            if (this.firstRecordedTimestamp &&
-                this.lastRecordedTimestamp &&
-                !this.isVideoLengthNegativeInvalid) {
-                totalVideoTime =
-                    this.lastRecordedTimestamp - this.firstRecordedTimestamp;
+    handleFragPost() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // check if inactive before any processing
+            if (yield MetroplexSocket.getInstance().closeIfInactive()) {
+                return;
             }
-            // In the past we have seen the video LengthMS field to be negative
-            // and bigger than the long limit of scala. Which is less than the
-            // safe integer limit of js.
-            if (!this.isVideoLengthNegativeInvalid &&
-                (totalVideoTime < 0 || totalVideoTime >= Number.MAX_SAFE_INTEGER)) {
-                // we log an error to know if this is still happening
-                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`video lengthMS is invalid: ${totalVideoTime}, ` +
-                    `start time: ${this.firstRecordedTimestamp}, ` +
-                    `end time: ${this.lastRecordedTimestamp}`, false, SEVERITY.error);
-                this.isVideoLengthNegativeInvalid = true;
-                totalVideoTime = 0;
+            if (!this.didSetupRecorder) {
+                return;
             }
-            this.vfCounter += 1;
-            const videoFragment = MetroplexSocket.getInstance().addEndTimeToPayload({
-                // single string for the video content. This gets converted to bytes
-                // when being sent to metroplex which we will then unmarshall into
-                // a struct to parse it's inner urls
-                // If stringifying this event buffer takes too long consider using a service worker
-                [VIDEO_FRAG_ATT_NAME]: stringifyJSON(this.eventBuffer),
-                // Send the sequence number but don't send the expected length since that is sent as
-                // part of the last stored metrics data
-                [PV_SEQ_ATT_NAME]: this.vfCounter,
-                [LENGTH_ATT_NAME]: totalVideoTime,
-                [CSS_URLS_ATT_NAME]: [],
-            }, false);
-            StoredMetrics.getInstance().addVideoFragData(this.vfCounter, totalVideoTime);
-            // constructing a client message that metroplex knows how to handle.
-            await MetroplexSocket.getInstance().sendMessage(VIDEO_METROPLEX_TYPE, {
-                [PAGE_VISIT_VID_FRAG_ATT_NAME]: videoFragment,
-            });
-            this.lastFragPostTimestamp = Date.now();
-        }
-        catch (err) {
-            // letting collect know we are closing the rrweb listener
-            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`video frag socket closed with err: ${err.message}`, false, SEVERITY.error);
-            // if we detect an error in the frag posting, we stop recording
-            // the video
-            this.freeze();
-        }
-        this.eventBuffer = [];
+            if (this.eventBuffer.length === 0) {
+                return;
+            }
+            try {
+                let totalVideoTime = 0;
+                // checking if we have those values set in the first place
+                if (this.firstRecordedTimestamp &&
+                    this.lastRecordedTimestamp &&
+                    !this.isVideoLengthNegativeInvalid) {
+                    totalVideoTime =
+                        this.lastRecordedTimestamp - this.firstRecordedTimestamp;
+                }
+                // In the past we have seen the video LengthMS field to be negative
+                // and bigger than the long limit of scala. Which is less than the
+                // safe integer limit of js.
+                if (!this.isVideoLengthNegativeInvalid &&
+                    (totalVideoTime < 0 || totalVideoTime >= Number.MAX_SAFE_INTEGER)) {
+                    // we log an error to know if this is still happening
+                    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`video lengthMS is invalid: ${totalVideoTime}, ` +
+                        `start time: ${this.firstRecordedTimestamp}, ` +
+                        `end time: ${this.lastRecordedTimestamp}`, false, SEVERITY.error);
+                    this.isVideoLengthNegativeInvalid = true;
+                    totalVideoTime = 0;
+                }
+                this.vfCounter += 1;
+                const videoFragment = MetroplexSocket.getInstance().addEndTimeToPayload({
+                    // single string for the video content. This gets converted to bytes
+                    // when being sent to metroplex which we will then unmarshall into
+                    // a struct to parse it's inner urls
+                    // If stringifying this event buffer takes too long consider using a service worker
+                    [VIDEO_FRAG_ATT_NAME]: stringifyJSON(this.eventBuffer),
+                    // Send the sequence number but don't send the expected length since that is sent as
+                    // part of the last stored metrics data
+                    [PV_SEQ_ATT_NAME]: this.vfCounter,
+                    [LENGTH_ATT_NAME]: totalVideoTime,
+                    [CSS_URLS_ATT_NAME]: [],
+                }, false);
+                StoredMetrics.getInstance().addVideoFragData(this.vfCounter, totalVideoTime);
+                // constructing a client message that metroplex knows how to handle.
+                yield MetroplexSocket.getInstance().sendMessage(VIDEO_METROPLEX_TYPE, {
+                    [PAGE_VISIT_VID_FRAG_ATT_NAME]: videoFragment,
+                });
+                this.lastFragPostTimestamp = Date.now();
+            }
+            catch (err) {
+                // letting collect know we are closing the rrweb listener
+                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`video frag socket closed with err: ${err.message}`, false, SEVERITY.error);
+                // if we detect an error in the frag posting, we stop recording
+                // the video
+                this.freeze();
+            }
+            this.eventBuffer = [];
+        });
     }
     /**
      * unfreeze forcefully resumes recording events in case it was frozen
      * waiting for user events
      */
-    async unfreeze() {
-        if (this.freezingEvents) {
-            this.didSetupRecorder = false;
-            await this.recordUserSession();
-        }
+    unfreeze() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.freezingEvents) {
+                this.didSetupRecorder = false;
+                yield this.recordUserSession();
+            }
+        });
     }
     /** stops recording */
     freeze() {

package/dist/{api → src/api}/clientConfig.d.ts

@@ -1,5 +1,5 @@
 import { SEVERITY } from '../constants';
-import { CustomerConfig, StoredConfig } from '../types/Config';
+import { CustomerConfig, StoredConfig } from '../../types/Config';
 /**
  * Singleton class to manage the client configuration
  * this class will be responsible for controlling the disabled

package/dist/{api → src/api}/metroplexSocket.d.ts

@@ -1,32 +1,32 @@
 import { END_AT_ATT_NAME } from '../constants';
 /** Manages the socket to Metroplex */
 export default class MetroplexSocket {
-    _initialURL: string;
-    ackedOnce: boolean;
-    connectionCount: number;
+    _initialURL: any;
+    ackedOnce: any;
+    connectionCount: any;
     connectionPromise: Promise<any>;
-    connectionURL: string;
-    currentConnectionAttempts: number;
-    forceClosed: boolean;
+    connectionURL: any;
+    currentConnectionAttempts: any;
+    forceClosed: any;
     helpCodeCb: null | ((...args: any[]) => any);
-    initialReferingURL: string;
+    initialReferingURL: any;
     static instance: MetroplexSocket;
-    instanceId: string | number[];
-    isRetryLoopDisabled: boolean;
-    latestReceivedSeqNumStoredTime: Date;
-    latestReceivedSeqNumber: number;
-    messageSequenceNum: number;
-    metroRetryFrequencyMS: 30000;
+    instanceId: any;
+    isRetryLoopDisabled: any;
+    latestReceivedSeqNumStoredTime: any;
+    latestReceivedSeqNumber: any;
+    messageSequenceNum: any;
+    metroRetryFrequencyMS: any;
     metroplexTypeLock: Record<any, any>;
-    pageVisitInfoSent: boolean;
-    postURL: string;
-    previousMessageType: string;
+    pageVisitInfoSent: any;
+    postURL: any;
+    previousMessageType: any;
     retryMessageQueue: any[];
     retryMetroplexInterval: null | number;
-    scriptInstanceId: string | number[] | undefined;
-    sessionLength: number;
+    scriptInstanceId: any;
+    sessionLength: any;
     sessionStartTime: any;
-    sessionTimestamp: Date;
+    sessionTimestamp: any;
     socket: WebSocket | null;
     socketInstanceId: string | number[] | null;
     socketCloseCodes: string[];
@@ -136,15 +136,15 @@ export default class MetroplexSocket {
         pv_id: string;
         v: 5;
         seq: number | null;
-        on_url: string;
-        ref_url: string;
-        start_at: string;
-        conc: number;
+        on_url: any;
+        ref_url: any;
+        start_at: any;
+        conc: any;
         cv: 2;
         last: boolean;
         script_id: string;
-        script_inst_id: string | number[] | undefined;
-        mp_sock_inst_id: string | number[];
+        script_inst_id: any;
+        mp_sock_inst_id: any;
         sock_inst_id: string | number[] | null;
         video_recorder: string;
     }>;

package/dist/{constants.d.ts → src/constants.d.ts}

@@ -243,3 +243,47 @@ export declare const BLOCKLISTED_DOMAINS: {
 export declare const MAX_RECORDER_EVENT_BUFFER = 10;
 export declare const MAX_TIME_FOR_RECORDER_USER_EVENTS = 2000;
 export declare const POST_METRICS_EVENT_NAME = "noibuPostMetrics";
+export declare const PAGE_CHECK_ERROR_ATT_NAME = "pagecheck_err";
+export declare const RESOURCE_ERROR_ATT_NAME = "res_err";
+export declare const GQL_EXTENSIONS_ATT_NAME = "extensions";
+export declare const GQL_LOCATIONS_ATT_NAME = "locations";
+export declare const GQL_SRC_ATT_NAME = "src";
+export declare const GQL_PATH_ATT_NAME = "path";
+export declare const GQL_LINE_ATT_NAME = "line";
+export declare const GQL_COLUMN_ATT_NAME = "column";
+export declare const GQL_MESSAGE_ATT_NAME = "message";
+export declare const GLOBAL_REASSIGN_ERROR_TYPE = "GlobalReassignError";
+export declare const PAGE_CHECK_ERROR_TYPE = "PageCheckError";
+export declare const IMAGE_ERROR_TYPE = "ImageError";
+export declare const JS_STACK_CAUSE_ATT_NAME = "cause";
+export declare const CUSTOM_ATTRIBUTE_TOTAL_COUNT_ATT_NAME = "cust_attr_total";
+export declare const CUSTOM_ATTRIBUTE_FAIL_COUNT_ATT_NAME = "cust_attr_fail";
+export declare const CUSTOM_ATTRIBUTE_KEY_COUNT_ATT_NAME = "cust_attr_key";
+export declare const OTHER_METRICS_ATT_NAME = "omm";
+export declare const OTHER_METRICS_KEYS: {
+    readonly STORAGE_FULL: "sf";
+    readonly STORAGE_UNAVAILABLE: "su";
+    readonly STORAGE_UNAVAILABLE_SECURITY_ERROR: "suse";
+};
+export declare const BODY_USED_ERROR = "Response data unavailable due to an improperly wrapped fetch call";
+export declare const MAX_HTTP_DATA_IF_ERROR_EVENT_COUNT = 120;
+export declare const MAX_SUCCESS_HTTP_DATA_PAYLOAD_LENGTH = 65536;
+export declare const LOCATION_EVENT_TYPE = "loc";
+export declare const ECOMMERCE_EVENT_TYPE = "ecommerce";
+export declare const NETWORK_STATS_EVENT_TYPE = "network";
+export declare const TITLE_EVENT_TYPE = "title";
+export declare const PAGE_TYPE_EVENT_TYPE = "page_type";
+export declare const HTTP_DATA_COLLECTION_FLAG_NAME = "http_data_collection";
+export declare const HTTP_DATA_PAYLOAD_URL_REGEXES_FLAG_NAME = "http_re";
+export declare const HELP_CODE_EVENT_NAME = "noibuHelpCode";
+export declare const ATTRIBUTE_SELECTORS_ATT_NAME = "att_sel";
+export declare const WIN_NJS_VERSION_ATT_NAME = "njs_version";
+export declare const WIN_SCRIPT_ID_ATT_NAME = "scriptID";
+export declare const WIN_BLOCKED_SELECTOR_ATT_NAME = "sel";
+export declare const DISABLED_STATUS_KEY = "DisabledStatus";
+export declare const CLIENT_UNLOCK_TIME_KEY = "ClientUnlockTime";
+export declare const BROWSER_ID_KEY = "BrowserId";
+export declare const CURRENT_PAGE_VISIT_COUNT_KEY = "CurrentPageVisitCount";
+export declare const PAGE_VISIT_ID_KEY = "pvId";
+export declare const LAST_ACTIVE_TIME_KEY = "LastActive";
+export declare const HELP_CODE_HASH_PARAM_NAME = "#helpcode";

package/dist/{entry → src/entry}/init.d.ts

@@ -1,4 +1,4 @@
-import { CustomerConfig } from '../types/Config';
+import { CustomerConfig } from '../../types/Config';
 /**
  * initilializes the script to start executing all of NJS features
  */

package/dist/{monitors → src/monitors}/clickMonitor.d.ts

@@ -34,7 +34,7 @@ export class ClickMonitor {
      * @param {Number} textLimit
      * @param {Object} counter
      */
-    _parseInnerContent(element: NReactNative.Node, text: string, textLimit: number, counter: Object): string;
+    _parseInnerContent(element: NReactNative.Node, text: string, textLimit: number, counter: any): string;
     /**
      * normalize value and append to the resulting text if not empty
      * @param {String} text

package/dist/{monitors → src/monitors}/gqlErrorValidator.d.ts

@@ -5,11 +5,11 @@ export default class GqlErrorValidator {
     /**
      * Retrieves GQL error object based on fetch request/response
      * @param {String} url
-     * @param {{}} options
-     * @param {Request} request
-     * @param {Response} response - cloned() from original response
+     * @param {{}} [options]
+     * @param {Request} [request]
+     * @param {Response} [response] - cloned() from original response
      */
-    static fromFetch(url: string, options: {}, request: Request, response: Response): Promise<any>;
+    static fromFetch(url: string, options?: {} | undefined, request?: Request | undefined, response?: Response | undefined): Promise<any>;
     /**
      * Retrieves GQL error object based on XHR object
      * @param {String} url
@@ -24,9 +24,9 @@ export default class GqlErrorValidator {
     /**
      * Try to get content type for fetch arguments
      * @param {{}} options
-     * @param {Request} request
+     * @param {Request} [request]
      */
-    static _getContentTypeFromFetchArguments(options: {}, request: Request): string | null;
+    static _getContentTypeFromFetchArguments(options: {}, request?: Request | undefined): string | null;
     /**
      * Checks if request is aborted
      * If it has been aborder we are not able to consume the response