noibu-react-native 0.2.5 → 0.2.7

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

@@ -1,17 +1,45 @@
 import { __awaiter } from 'tslib';
-import { HUMAN_READABLE_CONTENT_TYPE_REGEX, DEFAULT_WEBSITE_SUBDOMAIN_PATTERN, SEVERITY, HTTP_BODY_NULL_STRING, HTTP_DATA_REQ_HEADERS_ATT_NAME, HTTP_DATA_PAYLOAD_ATT_NAME, HTTP_DATA_RESP_HEADERS_ATT_NAME, HTTP_DATA_RESP_PAYLOAD_ATT_NAME, HTTP_BODY_DROPPED_LENGTH_MSG, HTTP_BODY_DROPPED_TYPE_MSG, CONTENT_TYPE, CONTENT_LENGTH, BLOCKED_HTTP_HEADER_KEYS, PII_REDACTION_REPLACEMENT_STRING, MAX_HTTP_DATA_PAYLOAD_LENGTH, MAX_SUCCESS_HTTP_DATA_PAYLOAD_LENGTH } from '../../constants.js';
-import ClientConfig from '../../api/clientConfig.js';
-import StoredMetrics from '../../api/storedMetrics.js';
+import { SEVERITY, CONTENT_TYPE, PII_REDACTION_REPLACEMENT_STRING } from '../../constants.js';
+import ClientConfig from '../../api/ClientConfig.js';
+import StoredMetrics from '../../api/StoredMetrics.js';
 import { safeFromEntries, safeEntries } from '../../utils/object.js';
-import { safeTrim, stringifyJSON, isString } from '../../utils/function.js';
+import { safeTrim, stringifyJSON } from '../../utils/function.js';
 import { removePII } from '../../utils/piiRedactor.js';
 import { Singleton } from '../BaseMonitor.js';
 
+const DEFAULT_WEBSITE_SUBDOMAIN_PATTERN = /^www\d{0,2}$/;
+const CONTENT_LENGTH = 'content-length';
+const HTTP_BODY_DROPPED_TYPE_MSG = 'Dropped due to unsupported type.';
+const HTTP_BODY_DROPPED_LENGTH_MSG = 'Dropped due to length.';
+const HTTP_BODY_NULL_STRING = 'null';
+// the maximum size of http data payload that will be capture for success, otherwise it is dropped
+// this is 64k
+const MAX_SUCCESS_HTTP_DATA_PAYLOAD_LENGTH = 65536;
+// the maximum size of http data payload that will be captured, otherwise it is dropped
+const MAX_HTTP_DATA_PAYLOAD_LENGTH = 50000;
+// regex of human readable content based on content-type header
+const HUMAN_READABLE_CONTENT_TYPE_REGEX = 'text|json|xml|html|graphql|x-www-form-urlencoded|form-data';
+// HTTP request/response header keys to be blocked - these must be lowercase.
+const BLOCKED_HTTP_HEADER_KEYS = [
+    'authorization',
+    'from',
+    'proxy-authorization',
+    'content-md5',
+    'cookie',
+    'x-forwarded-for',
+    'x-real-ip',
+    'x-device-id',
+    'x-request-id',
+    'x-auth-token',
+    'x-user-id',
+    'x-forwarded-for',
+    'x-uidh',
+    'set-cookie',
+    'forwarded',
+];
 /** Bundles HTTP payloads and headers */
 class HTTPDataBundler extends Singleton {
-    /**
-     * Creates an instance of the ClickMonitor instance
-     */
+    /** Creates an instance of the ClickMonitor instance */
     constructor() {
         super();
         // compile regex only once
@@ -32,11 +60,10 @@ class HTTPDataBundler extends Singleton {
                 this.initialURLPartsReversed.reverse();
             }
             catch (e) {
-                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Unable to determine hostname for initial URL: ${e}`, false, SEVERITY.warn);
+                ClientConfig.getInstance().postInternalError({ msg: `Unable to determine hostname for initial URL`, error: e }, false, SEVERITY.warn);
             }
         }
-        this.httpDataCollectionEnabled =
-            !!ClientConfig.getInstance().enableHttpDataCollection;
+        this.httpDataCollectionEnabled = !!ClientConfig.getInstance().enableHttpDataCollection;
         // compile the relative and full HTTP URL regexes
         const allowedURLs = ClientConfig.getInstance().listOfUrlsToCollectHttpDataFrom;
         this.httpDataAllowedAbsoluteRegex = HTTPDataBundler.buildAllowedRegex(allowedURLs, true);
@@ -47,7 +74,7 @@ class HTTPDataBundler extends Singleton {
     }
     /**
      * Builds the HTTP payload allowed regexes for full and relative URLs
-     * @param allowedURLs A list of allowed URLs
+     * @param allowedURLs Target list of allowed URLs
      * @param absolute Use only absolute URLs if true, use only relative URL if false
      * @returns a regex of allowed URLs
      */
@@ -138,36 +165,34 @@ class HTTPDataBundler extends Singleton {
                     return text;
                 }
                 catch (e) {
-                    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Unable to stringify JSON response: ${e}`, false, SEVERITY.warn);
+                    ClientConfig.getInstance().postInternalError({ msg: `Unable to stringify JSON response`, error: e }, false, SEVERITY.warn);
                     return null;
                 }
             }
             return null;
         });
     }
-    /**
-     * Builds an HTTP Data bundle
-     */
-    bundleHTTPData(url, requestHeaders, rawRequestPayload, responseHeaders, rawResponsePayload, method, isError) {
+    /** Builds an HTTP Data bundle */
+    bundleHTTPData(url, rawRequestHeaders, rawRequestPayload, rawResponseHeaders, rawResponsePayload, method, isError) {
         if (!this.isValidRequest(method)) {
             return null;
         }
         // stringify payload if correct type and not too large
-        let requestPayload = '';
-        let responsePayload = '';
+        let stringifiedRequestPayload = '';
+        let stringifiedResponsePayload = '';
         if (this.shouldCollectPayloadForURL(url)) {
-            requestPayload =
-                this.getReasonPayloadIsDropped(requestHeaders, isError) ||
-                    this.stringFromRequestBody(rawRequestPayload, requestHeaders);
-            responsePayload =
-                this.getReasonPayloadIsDropped(responseHeaders, isError) ||
-                    this.stringFromRequestBody(rawResponsePayload, responseHeaders);
+            stringifiedRequestPayload =
+                this.getReasonPayloadIsDropped(rawRequestHeaders, isError) ||
+                    this.stringFromRequestBody(rawRequestPayload, rawRequestHeaders);
+            stringifiedResponsePayload =
+                this.getReasonPayloadIsDropped(rawResponseHeaders, isError) ||
+                    this.stringFromRequestBody(rawResponsePayload, rawResponseHeaders);
         }
         // don't bundle if there is no data
-        const safeRequestHeaders = requestHeaders || new Map();
-        const safeRequestPayload = requestPayload || '';
-        const safeResponseHeaders = responseHeaders || new Map();
-        const safeResponsePayload = responsePayload || '';
+        const safeRequestHeaders = rawRequestHeaders || new Map();
+        const safeRequestPayload = stringifiedRequestPayload || '';
+        const safeResponseHeaders = rawResponseHeaders || new Map();
+        const safeResponsePayload = stringifiedResponsePayload || '';
         if (safeRequestHeaders.size === 0 &&
             !safeRequestPayload &&
             safeResponseHeaders.size === 0 &&
@@ -175,17 +200,17 @@ class HTTPDataBundler extends Singleton {
             return null;
         }
         // Ensure payloads do not exceed the maximum size and redact PII
-        const requestPayloadUpdated = this.restrictPayload(safeRequestPayload, url, isError);
+        const requestPayload = this.restrictPayload(safeRequestPayload, url, isError);
         // Ensure payloads do not exceed the maximum size and redact PII
-        const responsePayloadUpdated = this.restrictPayload(safeResponsePayload, url, isError);
+        const responsePayload = this.restrictPayload(safeResponsePayload, url, isError);
         // Redact PII.
-        const cleanRequestHeaders = safeFromEntries(this.removePIIHeaders(requestHeaders));
-        const cleanResponseHeaders = safeFromEntries(this.removePIIHeaders(responseHeaders));
+        const requestHeaders = safeFromEntries(this.removePIIHeaders(rawRequestHeaders));
+        const responseHeaders = safeFromEntries(this.removePIIHeaders(rawResponseHeaders));
         return {
-            [HTTP_DATA_REQ_HEADERS_ATT_NAME]: cleanRequestHeaders,
-            [HTTP_DATA_PAYLOAD_ATT_NAME]: requestPayloadUpdated,
-            [HTTP_DATA_RESP_HEADERS_ATT_NAME]: cleanResponseHeaders,
-            [HTTP_DATA_RESP_PAYLOAD_ATT_NAME]: responsePayloadUpdated,
+            rqh: requestHeaders,
+            rqp: requestPayload,
+            rsh: responseHeaders,
+            rsp: responsePayload,
         };
     }
     /**
@@ -193,7 +218,7 @@ class HTTPDataBundler extends Singleton {
      * de-duping the requests
      */
     isValidRequest(method) {
-        return (this.httpDataCollectionEnabled && method && typeof method === 'string');
+        return this.httpDataCollectionEnabled && method && typeof method === 'string';
     }
     /**
      * Checks two things: that the URL is either on the same domain (or an address relative to the
@@ -256,7 +281,7 @@ class HTTPDataBundler extends Singleton {
             return HTTP_BODY_NULL_STRING;
         }
         if (typeof payload !== 'string') {
-            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient({
+            ClientConfig.getInstance().postInternalError({
                 msg: `restrictPayload received non string payload`,
                 payloadType: typeof payload,
             }, false, SEVERITY.error);
@@ -264,20 +289,12 @@ class HTTPDataBundler extends Singleton {
         }
         if (payload === HTTP_BODY_NULL_STRING ||
             (!!payload.startsWith &&
-                (payload.startsWith(HTTP_BODY_DROPPED_LENGTH_MSG) ||
-                    payload.startsWith(HTTP_BODY_DROPPED_TYPE_MSG))) ||
+                (payload.startsWith(HTTP_BODY_DROPPED_LENGTH_MSG) || payload.startsWith(HTTP_BODY_DROPPED_TYPE_MSG))) ||
             (!!payload.indexOf &&
-                (payload.indexOf(HTTP_BODY_DROPPED_LENGTH_MSG) === 0 ||
-                    payload.indexOf(HTTP_BODY_DROPPED_TYPE_MSG) === 0))) {
+                (payload.indexOf(HTTP_BODY_DROPPED_LENGTH_MSG) === 0 || payload.indexOf(HTTP_BODY_DROPPED_TYPE_MSG) === 0))) {
             return payload;
         }
-        let restrictSize = isError
-            ? MAX_HTTP_DATA_PAYLOAD_LENGTH
-            : MAX_SUCCESS_HTTP_DATA_PAYLOAD_LENGTH;
-        // TODO CHARLIE: Temporary hack for www.holtrenfrew.com to limit them to 1.5MB to help solve a bug
-        if (this.hostname === 'www.holtrenfrew.com') {
-            restrictSize = 1.5 * 1024 * 1024;
-        }
+        const restrictSize = isError ? MAX_HTTP_DATA_PAYLOAD_LENGTH : MAX_SUCCESS_HTTP_DATA_PAYLOAD_LENGTH;
         if (payload.length > restrictSize) {
             StoredMetrics.getInstance().addHttpDataDropByLength();
             return `${HTTP_BODY_DROPPED_LENGTH_MSG} Payload length: ${payload.length}`;
@@ -290,19 +307,11 @@ class HTTPDataBundler extends Singleton {
      * Returns true if the content-length header is of acceptable size.
      * Too big gets rejected
      * If the headers are not found, check actual content for length
-     * @param  {Headers} headers
-     * @returns boolean true if acceptable to collect
      */
     contentLengthAcceptable(headers, isError) {
         // TODO This entire check should move into the parent's parent so there is a single place
         // that restricts paylods and unterstands these 2 values
-        let restrictSize = isError
-            ? MAX_HTTP_DATA_PAYLOAD_LENGTH
-            : MAX_SUCCESS_HTTP_DATA_PAYLOAD_LENGTH;
-        // TODO CHARLIE: Temporary hack for www.holtrenfrew.com to limit them to 1.5MB to help solve a bug
-        if (this.hostname === 'www.holtrenfrew.com') {
-            restrictSize = 1.5 * 1024 * 1024;
-        }
+        const restrictSize = isError ? MAX_HTTP_DATA_PAYLOAD_LENGTH : MAX_SUCCESS_HTTP_DATA_PAYLOAD_LENGTH;
         return this.contentLength(headers) <= restrictSize;
     }
     /**
@@ -314,8 +323,7 @@ class HTTPDataBundler extends Singleton {
     contentTypeAcceptable(headersMap) {
         // check content type
         const contentType = headersMap.get(CONTENT_TYPE);
-        return !(contentType &&
-            !this.contentTypeReadableRegex.test(contentType.toLowerCase()));
+        return !(contentType && !this.contentTypeReadableRegex.test(contentType.toLowerCase()));
     }
     /**
      * Returns a descriptive string if we have to drop payload based on the length
@@ -375,12 +383,9 @@ class HTTPDataBundler extends Singleton {
         if (value == null)
             return null;
         try {
-            if (isString(value) && requestHeaders instanceof Map) {
+            if ((typeof value === 'string' || value instanceof String) && requestHeaders instanceof Map) {
                 const contentType = requestHeaders.get(CONTENT_TYPE);
-                if (contentType &&
-                    contentType
-                        .toLowerCase()
-                        .includes('application/x-www-form-urlencoded')) {
+                if (contentType && contentType.toLowerCase().includes('application/x-www-form-urlencoded')) {
                     value = new URLSearchParams(value.toString());
                 }
             }
@@ -423,7 +428,7 @@ class HTTPDataBundler extends Singleton {
             return stringifyJSON(value);
         }
         catch (e) {
-            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Unable to stringify request body: ${e}`, false, SEVERITY.warn);
+            ClientConfig.getInstance().postInternalError({ msg: `Unable to stringify request body`, error: e }, false, SEVERITY.warn);
         }
         return null;
     }

package/dist/monitors/integrations/{react-native-navigation-integration.js → ReactNativeNavigationIntegration.js}

@@ -1,24 +1,22 @@
-/**
- * react-native-navigation adapter
- */
-class ReactNativeNavigationIntegration {
+import { Singleton } from '../BaseMonitor.js';
+
+/** react-native-navigation adapter */
+class ReactNativeNavigationIntegration extends Singleton {
     constructor() {
+        super(...arguments);
         this.stack = [];
         this.stackPointers = {};
     }
-    /**
-     * attaches provided listeners to the integration
-     */
+    /** Attaches provided listeners to the integration */
     register(navigation, onNavigation) {
-        navigation
-            .events()
-            .registerComponentWillAppearListener(this.getListener(onNavigation));
+        if (this.registration) {
+            this.registration.remove();
+        }
+        this.registration = navigation.events().registerComponentWillAppearListener(this.getListener(onNavigation));
     }
     /**
      * Listens to ComponentWillAppear events, keeps track of visited screens and
      * pops them if the same page is visited to prevent cycles
-     * @param onNavigation
-     * @private
      */
     getListener(onNavigation) {
         return (event) => {
@@ -37,6 +35,11 @@ class ReactNativeNavigationIntegration {
             onNavigation(this.stack.slice());
         };
     }
+    /** Destructor */
+    destroy() {
+        console.log('child destroy');
+        this.registration.remove();
+    }
 }
 
 export { ReactNativeNavigationIntegration };

package/dist/pageVisit/EventDebouncer.js

@@ -1,8 +1,7 @@
-import { PageVisit } from './pageVisit.js';
-import { APP_NAVIGATION_EVENT_TYPE, PAGE_EVENT_TYPE, MAX_TIME_FOR_UNSENT_DATA_MILLIS, ERROR_EVENT_TYPE, HTTP_EVENT_TYPE, KEYBOARD_EVENT_TYPE, SEVERITY } from '../constants.js';
-import { timestampWrapper } from '../utils/date.js';
+import { PageVisitManager } from './PageVisitManager.js';
+import { MAX_TIME_FOR_UNSENT_DATA_MILLIS } from '../constants.js';
+import { getOccurredNow } from '../utils/date.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
-import ClientConfig from '../api/clientConfig.js';
 import { Singleton } from '../monitors/BaseMonitor.js';
 
 /** @module EventDebouncer */
@@ -11,42 +10,35 @@ import { Singleton } from '../monitors/BaseMonitor.js';
  * that are registered
  */
 class EventDebouncer extends Singleton {
-    /**
-     * Creates an instance of EventDebouncer
-     */
+    /** Creates an instance of EventDebouncer */
     constructor() {
         super();
-        this.eventsToDebounce = {
-            [APP_NAVIGATION_EVENT_TYPE]: {
-                timeout: null,
-                events: [],
-                debouncePeriod: 0,
-                eventName: APP_NAVIGATION_EVENT_TYPE,
-            },
-            [PAGE_EVENT_TYPE]: {
-                timeout: null,
-                events: [],
-                debouncePeriod: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
-                eventName: PAGE_EVENT_TYPE,
-            },
-            [ERROR_EVENT_TYPE]: {
-                timeout: null,
-                events: [],
-                debouncePeriod: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
-                eventName: ERROR_EVENT_TYPE,
-            },
-            [HTTP_EVENT_TYPE]: {
-                timeout: null,
-                events: [],
-                debouncePeriod: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
-                eventName: HTTP_EVENT_TYPE,
-            },
-            [KEYBOARD_EVENT_TYPE]: {
-                timeout: null,
-                events: [],
-                debouncePeriod: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
-                eventName: KEYBOARD_EVENT_TYPE,
-            },
+        this.debouncePeriods = {
+            app_nav: 0,
+            page: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
+            err: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
+            http: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
+            userstep: MAX_TIME_FOR_UNSENT_DATA_MILLIS,
+        };
+        this.timeouts = {
+            app_nav: null,
+            page: null,
+            err: null,
+            http: null,
+            userstep: null,
+        };
+        this.events = {
+            app_nav: [],
+            page: [],
+            err: [],
+            http: [],
+            userstep: [],
+        };
+        /** Debounce function to be executed once the debounce period is completed */
+        this.sendEvents = (type) => {
+            this.timeouts[type] = null;
+            PageVisitManager.getInstance().addPageVisitEvents(this.events[type]);
+            this.events[type] = [];
         };
         this._setupUnloadHandler();
     }
@@ -54,45 +46,22 @@ class EventDebouncer extends Singleton {
      * Creates an event object with the event and the time it was added then pushes
      * that event object to the queue of events waiting to be debounced.
      */
-    addEvent(event, type, occurredAt) {
-        if (!(type in this.eventsToDebounce)) {
-            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(new Error(`Type: ${type} is not in eventsToDebounce`), false, SEVERITY.error);
-            return;
-        }
-        if (!occurredAt) {
-            occurredAt = Date.now();
-        }
-        this.eventsToDebounce[type].events.push({
-            event,
-            occurredAt: new Date(timestampWrapper(occurredAt)).toISOString(),
-        });
-        this._debouncePvEvents(type);
-    }
-    /**
-     * Adds the events from the object to the page visit and sets up a timer
-     * to send the events if no more are received without the timeout
-     */
-    _debouncePvEvents(type) {
-        /**
-         * Debounce function to be executed once the debounce period is completed
-         */
-        const later = () => {
-            this.eventsToDebounce[type].timeout = null;
-            PageVisit.getInstance().addPageVisitEvents(this.eventsToDebounce[type].events, this.eventsToDebounce[type].eventName);
-            this.eventsToDebounce[type].events = [];
-        };
-        if (this.eventsToDebounce[type].timeout !== null) {
-            clearTimeout(this.eventsToDebounce[type].timeout);
-        }
-        this.eventsToDebounce[type].timeout = setTimeout(later, this.eventsToDebounce[type].debouncePeriod);
+    debounce(event) {
+        const type = event.type;
+        const withTimestamp = Object.assign(Object.assign({}, event), { occ_at: getOccurredNow() });
+        const debouncePeriod = this.debouncePeriods[type];
+        this.events[type].push(withTimestamp);
+        clearTimeout(this.timeouts[type]);
+        this.timeouts[event.type] = setTimeout(() => this.sendEvents(type), debouncePeriod);
     }
     /** Sets up the page hide handler to try to push remaining events in the queues */
     _setupUnloadHandler() {
-        addSafeEventListener(window, 'pagehide', () => {
-            Object.values(this.eventsToDebounce).forEach(eventObject => {
-                PageVisit.getInstance().addPageVisitEvents(eventObject.events, eventObject.eventName);
-            });
-        });
+        addSafeEventListener(window, 'pagehide', () => Object.keys(this.debouncePeriods).forEach((key) => this.sendEvents(key)));
+    }
+    destroy() {
+        Object.values(this.timeouts)
+            .filter(t => !!t)
+            .forEach(clearTimeout);
     }
 }
 

package/dist/pageVisit/HttpEventManager.js

@@ -0,0 +1,88 @@
+import { PageVisitManager } from './PageVisitManager.js';
+import StoredMetrics from '../api/StoredMetrics.js';
+import MetroplexSocket from '../api/MetroplexSocket.js';
+import { safeTrim, getMaxSubstringAllowed, asString } from '../utils/function.js';
+import { EventDebouncer } from './EventDebouncer.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';
+
+/** @module PageVisitEventHTTP */
+/** http event manager */
+// maximum number of HTTP data events including errors to collect per page visit
+const MAX_HTTP_DATA_IF_ERROR_EVENT_COUNT = 120;
+// maximum number of HTTP data events to collect per page visit
+const MAX_HTTP_DATA_EVENT_COUNT = 100;
+/** if no value or it's less than 0, fallback to 0 */
+const validate = (value) => (!value || value < 0 ? 0 : value);
+/** Saves the HTTP event to the pageVisit Queue */
+function saveHTTPEvent(httpEvent, httpData, isGqlError = false) {
+    if (!httpEvent) {
+        return;
+    }
+    const url = safeTrim(getMaxSubstringAllowed(asString(httpEvent.url)));
+    // we do not store http events that have empty urls
+    if (!url) {
+        return;
+    }
+    const validatedEvent = {
+        code: validate(httpEvent.code),
+        r_time: validate(httpEvent.r_time),
+        mtd: (httpEvent.mtd || 'get').toUpperCase(),
+        url,
+    };
+    // we register an http event
+    StoredMetrics.getInstance().addHttpEvent();
+    // send http data down to metroplex
+    if (httpData) {
+        // add the sequence number to both events
+        const sequenceNumber = StoredMetrics.getInstance().httpSequenceNumber;
+        // restrict total number of events collected per page visit to ensure we don't
+        // blow up memory and storage usage
+        if (isSendAllowed(validatedEvent.code, sequenceNumber, isGqlError)) {
+            const httpDataWithSeq = Object.assign(Object.assign({}, httpData), { seq: sequenceNumber });
+            validatedEvent.seq = sequenceNumber;
+            // increment the count
+            StoredMetrics.getInstance().addHttpData();
+            MetroplexSocket.getInstance().sendMessage({ type: WebsocketMessageType.PageVisitHttp, payload: httpDataWithSeq });
+        }
+        else {
+            // have collected more than the max number of http requests for this
+            // page visit, so increment the over request limit count
+            StoredMetrics.getInstance().addHttpDataOverLimit();
+        }
+    }
+    const pve = {
+        type: EventType.Http,
+        http: validatedEvent,
+    };
+    // if this was an error, send immediately, so we don't lose it, delay otherwise
+    if (isAnError(validatedEvent.code, isGqlError)) {
+        PageVisitManager.getInstance().addPageVisitEvent(pve);
+    }
+    else {
+        EventDebouncer.getInstance().debounce(pve);
+    }
+    return validatedEvent.seq;
+}
+/** utility function to determine if status/flags combo is an error */
+function isAnError(status, isGqlError) {
+    return isHttpCodeFailure(status) || isGqlError;
+}
+/** Determines if a response is a failure */
+function isHttpCodeFailure(code) {
+    return typeof code !== 'number' ? true : code >= 400 || code <= 0;
+}
+/**
+ * Checks if sending data is allowed based on the HTTP status code and count.
+ * status - The HTTP status code to evaluate.
+ * count - The count of events to consider.
+ * isGqlError - Whether the context is considered as a GQL error.
+ * Returns `true` if sending data is allowed, `false` otherwise.
+ */
+function isSendAllowed(status, count, isGqlError = false) {
+    const threshold = isAnError(status, isGqlError) ? MAX_HTTP_DATA_IF_ERROR_EVENT_COUNT : MAX_HTTP_DATA_EVENT_COUNT;
+    return count < threshold;
+}
+
+export { isHttpCodeFailure, isSendAllowed, saveHTTPEvent };

package/dist/pageVisit/PageVisitManager.js

@@ -0,0 +1,99 @@
+import ClientConfig from '../api/ClientConfig.js';
+import MetroplexSocket from '../api/MetroplexSocket.js';
+import StoredMetrics from '../api/StoredMetrics.js';
+import { noibuLog } from '../utils/log.js';
+import { Singleton } from '../monitors/BaseMonitor.js';
+import { getOccurredNow } from '../utils/date.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { WebsocketMessageType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/WebsocketMessageType.js';
+
+/** @module Pagevisit */
+const MAX_PAGEVISIT_EVENTS = 200;
+const MAX_PAGEVISIT_PARTS = 10000;
+/**
+ * Singleton class to hold all the information
+ * about the gathered errors throught the session
+ */
+class PageVisitManager extends Singleton {
+    constructor() {
+        super(...arguments);
+        this.partCounter = 0;
+        this.pvEvents = [];
+        this.pvEventLength = 0;
+        // variables used for monitoring our posting frequency
+        this.visibilityChangedCounter = 0;
+        this.totalPvEventLength = 0;
+    }
+    /** adds page visit events into the current page visit map and then sends a page visit message
+     */
+    addPageVisitEvents(eventObjects) {
+        eventObjects.forEach(eventObj => this._addPageVisitEvent(eventObj));
+        this._sendPageVisitMessage();
+    }
+    /**
+     * adds the page visit event into the current page visit map and then sends a page visit message
+     * returns the key to access this event in the map
+     */
+    addPageVisitEvent(eventObj) {
+        const withTimestamp = Object.assign(Object.assign({}, eventObj), { occ_at: getOccurredNow() });
+        noibuLog('addPageVisitEvent', withTimestamp);
+        this._addPageVisitEvent(withTimestamp);
+        this._sendPageVisitMessage();
+    }
+    /**
+     * adds a new page visit event into the current page visit map and returns the
+     * the key to access this event in the map
+     */
+    _addPageVisitEvent(pvEvent) {
+        // if we are over the limit set by the Beacon API limit, we need to
+        // send what we currently have in the buffer to metroplex
+        if (this.pvEventLength >= MAX_PAGEVISIT_EVENTS) {
+            this._sendPageVisitMessage();
+        }
+        // updating sizes
+        this.pvEvents.push(pvEvent);
+        this.pvEventLength += 1;
+        this.totalPvEventLength += 1;
+    }
+    /**
+     * _sendPageVisitMessage will reset the buffer and post the current
+     * content to metroplex
+     */
+    _sendPageVisitMessage() {
+        if (this.pvEvents.length === 0) {
+            /**
+             * don't send to metroplex if the event buffer is empty.
+             * Target previous call to this function from visibilityChange
+             * would have sent it as a final post. Another reason it would be empty is
+             * if the user has not done anything on the page and switched tabs,
+             * or closed the browser etc
+             */
+            return;
+        }
+        if (this.partCounter >= MAX_PAGEVISIT_PARTS) {
+            /**
+             * if we are attempting to send over the MAX_PAGEVISIT_PARTS
+             * number of parts then we block any subsequent part post to not
+             * overwhelm our back end. We lock the client for 10 minute, something
+             * must be going bad.
+             */
+            ClientConfig.getInstance().lockClientUntilNextPage({
+                msg: 'NoibuJS will stop processing parts because we reached max parts',
+                MAX_PAGEVISIT_PARTS,
+                totalPvEventLength: this.totalPvEventLength,
+                visibilityChangedCounter: this.visibilityChangedCounter,
+            });
+            return;
+        }
+        const pvp = MetroplexSocket.getInstance().addEndTimeToPayload({ events: this.pvEvents, pc: this.partCounter }, true);
+        StoredMetrics.getInstance().setPvPart(this.partCounter);
+        MetroplexSocket.getInstance().sendMessage({ payload: pvp, type: WebsocketMessageType.PageVisitPart });
+        // since we sent the content of the buffer to metroplex, we reset
+        // all variables that contained information about the past buffer.
+        this.pvEvents = [];
+        this.pvEventLength = 0;
+        this.partCounter += 1;
+    }
+}
+
+export { PageVisitManager };