noibu-react-native 0.2.6 → 0.2.8

package/dist/{src/api/storedMetrics.d.ts → api/StoredMetrics.d.ts}

@@ -1,14 +1,10 @@
+import { Singleton } from '../monitors/BaseMonitor';
 /**
  * This class holds the final page visit and video frag metrics. It flushes
  * them to storage and then finally sends them to Metroplex via the post
  * route when the next page is loaded
  */
-export default class StoredMetrics {
-    /**
-     * gets the singleton instance
-     * @returns {StoredMetrics}
-     */
-    static getInstance(): StoredMetrics;
+export default class StoredMetrics extends Singleton {
     expectedVideoLength: number;
     expectedVfSeq: number;
     httpSequenceNumber: number;
@@ -23,17 +19,13 @@ export default class StoredMetrics {
     httpCount: number;
     didCutPv: boolean;
     didCutVideo: boolean;
-    writeTimeout: any;
     didStartVideo: boolean;
-    /** Add video frag payload data to the stored metrics
-     * @param  {} expectedVfSeq
-     * @param  {} expectedVideoLength
-     */
-    addVideoFragData(expectedVfSeq: any, expectedVideoLength: any): void;
-    /** Set the amount of page visit parts
-     * @param  {} expectedPvPart
-     */
-    setPvPart(expectedPvPart: any): void;
+    /** Creates a new StoredMetrics instance */
+    constructor();
+    /** Add video frag payload data to the stored metrics   */
+    addVideoFragData(expectedVfSeq: number, expectedVideoLength: number): void;
+    /** Set the amount of page visit parts   */
+    setPvPart(expectedPvPart: number): void;
     /** Increase the amount of video clicks seen in the session */
     addVideoClick(): void;
     /** Increase the amount of page visit clicks */
@@ -63,10 +55,8 @@ export default class StoredMetrics {
      * our metrics to localstorage
      */
     _setupListeners(): void;
-    /** posts the metrics to metroplex if client is active
-     * @param  {} eventName
-     */
-    _postMetricsIfActive(eventName: any): void;
+    /** posts the metrics to metroplex if client is active   */
+    private postMetricsIfActive;
     /** posts the metrics to metroplex using the beacon API
      */
     postMetrics(): Promise<void>;

package/dist/api/StoredMetrics.js

@@ -0,0 +1,158 @@
+import { __awaiter } from 'tslib';
+import { CURRENT_NOIBUJS_VERSION, GET_METROPLEX_METRICS_URL } from '../constants.js';
+import ClientConfig from './ClientConfig.js';
+import { getUserAgent, stringifyJSON } from '../utils/function.js';
+import { addSafeEventListener } from '../utils/eventlistener.js';
+import { unwrapNoibuWrapped } from '../utils/object.js';
+import { Singleton } from '../monitors/BaseMonitor.js';
+
+// current metrics version to be sent from front end services.
+const CURRENT_METRICS_VERSION = 1;
+/**
+ * This class holds the final page visit and video frag metrics. It flushes
+ * them to storage and then finally sends them to Metroplex via the post
+ * route when the next page is loaded
+ */
+class StoredMetrics extends Singleton {
+    /** Creates a new StoredMetrics instance */
+    constructor() {
+        super();
+        this.expectedVideoLength = 0;
+        this.expectedVfSeq = 0;
+        this.httpSequenceNumber = 0;
+        this.httpOverLimitCount = 0;
+        this.httpDroppedPayloadByTypeCount = 0;
+        this.httpDroppedPayloadByLengthCount = 0;
+        this.httpPayloadCount = 0;
+        this.expectedPvPart = 0;
+        this.videoClicks = 0;
+        this.pvClicks = 0;
+        this.errCount = 0;
+        this.httpCount = 0;
+        this.didCutPv = false;
+        this.didCutVideo = false;
+        this.didStartVideo = false;
+        this._setupListeners();
+    }
+    /** Add video frag payload data to the stored metrics   */
+    addVideoFragData(expectedVfSeq, expectedVideoLength) {
+        this.expectedVfSeq = expectedVfSeq;
+        this.expectedVideoLength = expectedVideoLength;
+    }
+    /** Set the amount of page visit parts   */
+    setPvPart(expectedPvPart) {
+        this.expectedPvPart = expectedPvPart;
+    }
+    /** Increase the amount of video clicks seen in the session */
+    addVideoClick() {
+        this.videoClicks += 1;
+    }
+    /** Increase the amount of page visit clicks */
+    addPvClick() {
+        this.pvClicks += 1;
+    }
+    /** Increments the error count by 1 */
+    addError() {
+        this.errCount += 1;
+    }
+    /** Increments the http count by 1 */
+    addHttpEvent() {
+        this.httpCount += 1;
+    }
+    /** Increments the http data sequence count by 1 */
+    addHttpData() {
+        this.httpSequenceNumber += 1;
+    }
+    /** Increments the http data over limit count by 1 */
+    addHttpDataOverLimit() {
+        this.httpOverLimitCount += 1;
+    }
+    /** Increments the http data drop count by content type */
+    addHttpDataDropByType() {
+        this.httpDroppedPayloadByTypeCount += 1;
+    }
+    /** Increments the http data drop count by content length */
+    addHttpDataDropByLength() {
+        this.httpDroppedPayloadByLengthCount += 1;
+    }
+    /** Increments the http data payload collected count */
+    addHttpDataPayloadCount() {
+        this.httpPayloadCount += 1;
+    }
+    /** Set that the video was cut/blocked due to size constraints */
+    setDidCutVideo() {
+        this.didCutVideo = true;
+    }
+    /** Set that the video was started */
+    setDidStartVideo() {
+        this.didStartVideo = true;
+    }
+    /** Set that the page visit was cut/blocked due to size constraints */
+    setDidCutPv() {
+        this.didCutPv = true;
+    }
+    /**
+     * Sets up all the listeners that noibujs should listen to before storing
+     * our metrics to localstorage
+     */
+    _setupListeners() {
+        // Add the window event handlers to post the data to the metrics endpoint
+        const evt = 'pagehide';
+        addSafeEventListener(window, evt, () => this.postMetricsIfActive());
+    }
+    /** posts the metrics to metroplex if client is active   */
+    postMetricsIfActive() {
+        if (ClientConfig.getInstance().isClientDisabled) {
+            return;
+        }
+        // Don't send the metrics if the session has become inactive
+        // already sent when went inactive
+        if (ClientConfig.getInstance().isInactive()) {
+            return;
+        }
+        return this.postMetrics();
+    }
+    /** posts the metrics to metroplex using the beacon API
+     */
+    postMetrics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Create a new object to write to local storage that doesnt have the timeout and flush members.
+            const lsMetrics = {
+                // metadata
+                br_id: ClientConfig.getInstance().browserId,
+                pv_id: ClientConfig.getInstance().pageVisitId,
+                cv: CURRENT_NOIBUJS_VERSION,
+                v: CURRENT_METRICS_VERSION,
+                // metrics
+                exp_vid_len: this.expectedVideoLength,
+                exp_vf_seq: this.expectedVfSeq,
+                exp_pc_seq: this.expectedPvPart,
+                exp_http_seq: this.httpSequenceNumber,
+                http_payloads: this.httpPayloadCount,
+                http_drop_oversize: this.httpDroppedPayloadByLengthCount,
+                http_drop_type: this.httpDroppedPayloadByTypeCount,
+                http_over_limit: this.httpOverLimitCount,
+                vid_clicks: this.videoClicks,
+                pv_clicks: this.pvClicks,
+                did_cut_pv: this.didCutPv,
+                did_cut_vid: this.didCutVideo,
+                did_start_vid: this.didStartVideo,
+                exp_http: this.httpCount,
+                exp_err: this.errCount,
+                on_url: ClientConfig.getInstance().globalUrl,
+            };
+            unwrapNoibuWrapped(fetch)(GET_METROPLEX_METRICS_URL(), {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    'User-Agent': yield getUserAgent(),
+                },
+                body: stringifyJSON(lsMetrics),
+                // keep alive outlives the current page, its the same as beacon
+                keepalive: true,
+            });
+        });
+    }
+}
+
+export { StoredMetrics as default };

package/dist/{src/api/storedPageVisit.d.ts → api/StoredPageVisit.d.ts}

@@ -1,30 +1,33 @@
-import { CompletePageVisit, PageVisitFrag, PageVisitInfo, SlidingMessage } from '../../types/Metroplex.types';
 import { Singleton } from '../monitors/BaseMonitor';
+import { RetryQueueWSMessage } from '../types/Metroplex';
+import { CompletePageVisitPart, PageInformation, PageVisitPart } from '@noibu/metroplex-ts-bindings';
 /**
  * This class holds the final page visit. It flushes it to storage and then
  * finally sends it to Metroplex via the post route when the next page is loaded
  */
 export default class StoredPageVisit extends Singleton {
-    /**
-     * Creates a new instance of StoredPageVisit
-     */
+    /** Creates a new instance of StoredPageVisit */
     constructor();
     /**
      * Check if the events contain a click or location change. If they do then write the retry
      * queue (which contains the metroplex msg sent above) to storage
      */
-    checkAndStoreRetryQueue(retryMessageQueue: SlidingMessage[], pvInfo: PageVisitInfo): void;
+    checkAndStoreRetryQueue(retryMessageQueue: RetryQueueWSMessage[], pvInfo: PageInformation): void;
     /** Writes the page visit frags in the retry queue to storage
      */
-    writePageVisitsFromRetryQueue(retryMessageQueue: SlidingMessage[], pvInfo: PageVisitInfo): void;
+    writePageVisitsFromRetryQueue(retryMessageQueue: RetryQueueWSMessage[], pvInfo: PageInformation): void;
     /** Write the given page visit frags to storage
      */
-    _writePageVisitFrags(pageVisitFrags: PageVisitFrag[], pvInfo: PageVisitInfo): Promise<void>;
+    _writePageVisitFrags(pageVisitFrags: PageVisitPart[], pvInfo: PageInformation): Promise<void>;
+    /**
+     * Handles any issues that may appear when trying to get the stored page visit data
+     */
+    static handleGetPostDataError(data: string, error: Error): Promise<null>;
     /**
      * Read the stored page visit from storage, create a complete page visit object
      * and then post that to Metroplex
      */
-    _getPostData(): Promise<CompletePageVisit>;
+    _getPostData(): Promise<CompletePageVisitPart | null>;
     /**
      * Creates and tries to resolve a promise that posts the previous page visit
      * to Metroplex from storage

package/dist/api/{storedPageVisit.js → StoredPageVisit.js}

@@ -1,18 +1,22 @@
 import { __awaiter } from 'tslib';
-import { PV_METROPLEX_TYPE, PAGE_VISIT_PART_ATT_NAME, PV_EVENTS_ATT_NAME, TYPE_ATT_NAME, USERSTEP_EVENT_TYPE, ERROR_EVENT_TYPE, NOIBU_STORED_PAGE_VISIT, SEVERITY, MAX_METROPLEX_SOCKET_INNACTIVE_TIME, PAGE_VISIT_INFORMATION_ATT_NAME, PAGE_VISIT_VID_FRAG_ATT_NAME, IS_LAST_ATT_NAME, GET_METROPLEX_POST_URL } from '../constants.js';
-import ClientConfig from './clientConfig.js';
-import { stringifyJSON, makeRequest } from '../utils/function.js';
-import Storage from '../storage/storage.js';
+import { MAX_METROPLEX_SOCKET_INNACTIVE_TIME, GET_METROPLEX_POST_URL } from '../constants.js';
+import ClientConfig from './ClientConfig.js';
+import { stringifyJSON, postRequest } from '../utils/function.js';
+import Storage from '../storage/Storage.js';
 import { Singleton } from '../monitors/BaseMonitor.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
+import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { Severity } from '../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 
+// The local storage key used to store the last page visit
+const NOIBU_STORED_PAGE_VISIT = 'n_stored_page_visit';
 /**
  * This class holds the final page visit. It flushes it to storage and then
  * finally sends it to Metroplex via the post route when the next page is loaded
  */
 class StoredPageVisit extends Singleton {
-    /**
-     * Creates a new instance of StoredPageVisit
-     */
+    /** Creates a new instance of StoredPageVisit */
     constructor() {
         super();
         const storage = Storage.getInstance();
@@ -29,18 +33,15 @@ class StoredPageVisit extends Singleton {
         // Get the events from the last message
         const { type, payload } = retryMessageQueue[retryMessageQueue.length - 1];
         // Only store page visit payloads
-        if (type !== PV_METROPLEX_TYPE || !payload[PAGE_VISIT_PART_ATT_NAME]) {
+        if (type !== WebsocketMessageType.PageVisitPart || !payload) {
             return;
         }
-        const events = payload[PAGE_VISIT_PART_ATT_NAME][PV_EVENTS_ATT_NAME]
-            ? payload[PAGE_VISIT_PART_ATT_NAME][PV_EVENTS_ATT_NAME]
-            : [];
+        const events = payload.events ? payload.events : [];
         const filteredEvents = events.filter(event => 
-        // Return true if the event is a userstep, error, or location event
+        // Return true if the event is an userstep, error, or location event
         // Any userstep is used rather than just mouse clicks because we shouldn't
         // assume mouse clicks are the only way for any activity to happen
-        event[TYPE_ATT_NAME] === USERSTEP_EVENT_TYPE ||
-            event[TYPE_ATT_NAME] === ERROR_EVENT_TYPE);
+        event.type === EventType.UserStep || event.type === EventType.Error);
         // Only write the retry queue if it contains a user step or location change
         if (filteredEvents.length > 0) {
             this.writePageVisitsFromRetryQueue(retryMessageQueue, pvInfo);
@@ -52,9 +53,8 @@ class StoredPageVisit extends Singleton {
         const pageVisitFrags = [];
         for (let i = 0; i < retryMessageQueue.length; i += 1) {
             const { type, payload } = retryMessageQueue[i];
-            if (type === PV_METROPLEX_TYPE) {
-                const frag = payload[PAGE_VISIT_PART_ATT_NAME];
-                pageVisitFrags.push(frag);
+            if (type === WebsocketMessageType.PageVisitPart) {
+                pageVisitFrags.push(payload);
             }
         }
         this._writePageVisitFrags(pageVisitFrags, pvInfo);
@@ -74,16 +74,35 @@ class StoredPageVisit extends Singleton {
             try {
                 yield storage.save(NOIBU_STORED_PAGE_VISIT, json);
             }
-            catch (err) {
+            catch (error) {
                 yield storage.remove(NOIBU_STORED_PAGE_VISIT);
                 // Calculate current storage size
                 const size = yield storage.calculateUsedSize();
-                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error writing pv to storage: ${err}, ` +
-                    `json size: ${json.length}, storage size: ${size}, ` +
-                    `${yield storage.getDiagnoseInfo()}`, false, SEVERITY.error);
+                ClientConfig.getInstance().postInternalError({
+                    msg: `Error writing pv to storage`,
+                    error,
+                    jsonSize: json.length,
+                    storageSize: size,
+                    diagnosis: yield storage.getDiagnoseInfo(),
+                }, false, Severity.ERROR);
             }
         });
     }
+    /**
+     * Handles any issues that may appear when trying to get the stored page visit data
+     */
+    static handleGetPostDataError(data, error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Remove the item since there is something corrupted
+            yield Storage.getInstance().remove(NOIBU_STORED_PAGE_VISIT);
+            ClientConfig.getInstance().postInternalError({
+                msg: `Error parsing page visit string`,
+                data,
+                error,
+            }, false, Severity.ERROR);
+            return null;
+        });
+    }
     /**
      * Read the stored page visit from storage, create a complete page visit object
      * and then post that to Metroplex
@@ -99,12 +118,17 @@ class StoredPageVisit extends Singleton {
             let storedPageVisit = {};
             try {
                 storedPageVisit = JSON.parse(data);
+                if (!storedPageVisit.pageVisitInfo) {
+                    return StoredPageVisit.handleGetPostDataError(data, new TypeError('Page visit info is missing'));
+                }
+                if (!storedPageVisit.pageVisitFrags) {
+                    return StoredPageVisit.handleGetPostDataError(data, new TypeError('Page visit frags is missing'));
+                }
+                // Set is last to be true on the page visit information
+                storedPageVisit.pageVisitInfo.last = true;
             }
             catch (e) {
-                // Remove the item since there is something corrupted
-                yield storage.remove(NOIBU_STORED_PAGE_VISIT);
-                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error parsing page visit string '${data}': ${e}`, false, SEVERITY.error);
-                return null;
+                return StoredPageVisit.handleGetPostDataError(data, e);
             }
             // making sure we have the timestamp attribute since we added this logic after initially
             // releasing the storedPageVisit
@@ -120,16 +144,10 @@ class StoredPageVisit extends Singleton {
             }
             // Copy the page visit information from storage into a new complete PV
             const completePv = {
-                [PAGE_VISIT_INFORMATION_ATT_NAME]: storedPageVisit.pageVisitInfo,
-                [PAGE_VISIT_PART_ATT_NAME]: [],
-                [PAGE_VISIT_VID_FRAG_ATT_NAME]: [],
+                pvi: storedPageVisit.pageVisitInfo,
+                pvp: storedPageVisit.pageVisitFrags,
+                pvvf: [],
             };
-            // Set is last to be true on the page visit information
-            completePv[PAGE_VISIT_INFORMATION_ATT_NAME][IS_LAST_ATT_NAME] = true;
-            // Add the page visit frags to the complete PV
-            for (let i = 0; i < storedPageVisit.pageVisitFrags.length; i += 1) {
-                completePv[PAGE_VISIT_PART_ATT_NAME].push(storedPageVisit.pageVisitFrags[i]);
-            }
             return completePv;
         });
     }
@@ -152,20 +170,16 @@ class StoredPageVisit extends Singleton {
     }
     /** Returns a promise that resolves to post the page visit in storage to Metroplex */
     _getPostPageVisitPromise() {
-        return new Promise((resolve, reject) => {
-            this._getPostData().then(data => {
-                if (!data) {
-                    resolve();
-                    return;
-                }
-                const headers = {
-                    'content-type': 'application/json',
-                };
-                makeRequest('POST', GET_METROPLEX_POST_URL(), data, headers, 2000, true)
-                    .then(resolve)
-                    .catch(e => {
-                    reject(new Error('Page visit post request rejected due to: ', e));
-                });
+        return __awaiter(this, void 0, void 0, function* () {
+            const postData = yield this._getPostData();
+            if (!postData) {
+                return;
+            }
+            const headers = {
+                'content-type': 'application/json',
+            };
+            return postRequest(GET_METROPLEX_POST_URL(), postData, headers, true, 2000).catch(cause => {
+                Promise.reject(new Error('Page visit post request rejected due to: ', { cause }));
             });
         });
     }

package/dist/const_matchers.js

@@ -1,4 +1,3 @@
-/* eslint-disable require-jsdoc */
 // This file is generated by wsmatchers.   Don't directly edit this file
 const addToCartTextRegexArray = [
   '\\b(view|add|my)\\b.*\\b(cart|bag|basket|bucket|box)\\b',
@@ -251,10 +250,7 @@ const checkoutPlaceOrderRegexArray = [
 ];
 
 function WHITELIST_TEXT_REGEX_STRING() {
-  return addToCartTextRegexArray
-    .concat(checkoutStartedTextRegexArray)
-    .concat(checkoutPlaceOrderRegexArray)
-    .join('|');
+  return addToCartTextRegexArray.concat(checkoutStartedTextRegexArray).concat(checkoutPlaceOrderRegexArray).join('|');
 }
 
 export { WHITELIST_TEXT_REGEX_STRING };

package/dist/constants.d.ts

@@ -0,0 +1,48 @@
+/** @module Constants */
+export declare const CURRENT_NOIBUJS_VERSION = 2;
+export declare const MAX_STRING_LENGTH = 1024;
+export declare const MAX_TIME_FOR_UNSENT_DATA_MILLIS = 500;
+export declare const PII_EMAIL_PATTERN: RegExp;
+export declare const PII_REDACTION_REPLACEMENT_STRING = "******";
+export declare const SEVERITY: {
+    error: string;
+    warn: string;
+    info: string;
+    debug: string;
+};
+export declare const MAX_METROPLEX_SOCKET_INNACTIVE_TIME: number;
+export declare const MAX_BEACON_PAYLOAD_SIZE = 59000;
+export declare const CONTENT_TYPE = "content-type";
+/**
+ * Gets the script id from the cookie object, returns default if cannot be found
+ */
+export declare function GET_SCRIPT_ID(): string;
+/**
+ * Gets the max metro recon number
+ */
+export declare function GET_MAX_METROPLEX_RECONNECTION_NUMBER(): number;
+/**
+ * Returns the amount of time in milliseconds to delay a new connection by
+ * if we have exceeded the max consecutive connection count
+ */
+export declare function GET_METROPLEX_CONSECUTIVE_CONNECTION_DELAY(): number;
+/**
+ * gets the base url for metroplex's websocket connection
+ */
+export declare function GET_METROPLEX_BASE_SOCKET_URL(): string;
+/**
+ * gets the base url for metroplex's HTTP requests
+ */
+export declare function GET_METROPLEX_BASE_HTTP_URL(): string;
+/**
+ * Returns the URL that accepts http post requests
+ */
+export declare function GET_METROPLEX_POST_URL(): string;
+/**
+ * Returns the URL for posting metrics data to Metroplex
+ */
+export declare function GET_METROPLEX_METRICS_URL(): string;
+/**
+ * gets the current env
+ */
+export declare function GET_DEVICE_ENV(): string;