noibu-react-native 0.2.6 → 0.2.8

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.d.ts

@@ -0,0 +1,14 @@
+import { NoSeq } from '../types/Metroplex';
+import { PageVisitEventHTTP, RawHttpData } from '@noibu/metroplex-ts-bindings';
+/** Saves the HTTP event to the pageVisit Queue */
+export declare function saveHTTPEvent(httpEvent: Partial<PageVisitEventHTTP>, httpData?: NoSeq<RawHttpData> | null, isGqlError?: boolean): number | undefined;
+/** Determines if a response is a failure */
+export declare function isHttpCodeFailure(code: unknown): boolean;
+/**
+ * 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.
+ */
+export declare function isSendAllowed(status: number, count: number, isGqlError?: boolean): boolean;

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.d.ts

@@ -0,0 +1,31 @@
+import { Singleton } from '../monitors/BaseMonitor';
+import { PageVisitEvent } from '@noibu/metroplex-ts-bindings';
+/**
+ * Singleton class to hold all the information
+ * about the gathered errors throught the session
+ */
+export declare class PageVisitManager extends Singleton {
+    partCounter: number;
+    pvEvents: PageVisitEvent[];
+    pvEventLength: number;
+    visibilityChangedCounter: number;
+    totalPvEventLength: number;
+    /** adds page visit events into the current page visit map and then sends a page visit message
+     */
+    addPageVisitEvents(eventObjects: PageVisitEvent[]): void;
+    /**
+     * 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: Omit<PageVisitEvent, 'occ_at'>): void;
+    /**
+     * 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: PageVisitEvent): void;
+    /**
+     * _sendPageVisitMessage will reset the buffer and post the current
+     * content to metroplex
+     */
+    _sendPageVisitMessage(): void;
+}

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 };

package/dist/pageVisit/pageVisitEventError.d.ts

@@ -0,0 +1,12 @@
+import { Option, PageVisitEventError } from '@noibu/metroplex-ts-bindings';
+import { EventInput, PageVisitErrorInput } from '../types/PageVisitErrors';
+/**
+ * gets the onURL of a string, defaulting to the location of the webpage
+ */
+export declare function getOnURL(realOnURL: unknown): string;
+/**
+ * determines if an error is a collect error
+ */
+export declare function isErrorCollectedByNoibu(pvError: PageVisitEventError): Promise<false | void>;
+/** Saves the error to the Error queue */
+export declare function saveErrorToPagevisit<T extends PageVisitErrorInput | EventInput>(payload: T, httpDataSeqNum?: Option<number>): void;