noibu-react-native 0.2.5 → 0.2.7

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/api/{storedPageVisit.js → StoredPageVisit.js}

@@ -1,18 +1,21 @@
 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 { SEVERITY, 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';
 
+// 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 +32,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 +52,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 +73,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 +117,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 +143,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 +169,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 };