noibu-react-native 0.2.6 → 0.2.8

package/dist/monitors/KeyboardInputMonitor.js

@@ -1,8 +1,9 @@
-import { updatePayload } from '../pageVisit/userStep.js';
-import { SOURCE_ATT_NAME, TEXT_ATT_NAME, TAGNAME_ATT_NAME, TYPE_ATT_NAME, KEYBOARD_EVENT_TYPE } from '../constants.js';
 import { EventDebouncer } from '../pageVisit/EventDebouncer.js';
 import { TextInput } from 'react-native';
 import { Singleton } from './BaseMonitor.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { UserStepType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/UserStepType.js';
 
 /** @module KeyboardInputMonitor */
 /**
@@ -37,9 +38,7 @@ class KeyboardInputMonitor extends Singleton {
             };
         }
     }
-    /**
-     * Validates an event
-     */
+    /** Validates an event */
     static handle(uiViewClassName, props) {
         if (!/(text|input)/i.test(uiViewClassName)) {
             return;
@@ -48,12 +47,15 @@ class KeyboardInputMonitor extends Singleton {
         if (!name) {
             return;
         }
-        EventDebouncer.getInstance().addEvent(updatePayload({
-            [SOURCE_ATT_NAME]: '',
-            [TEXT_ATT_NAME]: name,
-            [TAGNAME_ATT_NAME]: uiViewClassName.toLowerCase(),
-            [TYPE_ATT_NAME]: KEYBOARD_EVENT_TYPE,
-        }), KEYBOARD_EVENT_TYPE);
+        EventDebouncer.getInstance().debounce({
+            type: EventType.UserStep,
+            userstep: {
+                src: '',
+                txt: name,
+                tag: uiViewClassName.toLowerCase(),
+                type: UserStepType.Keyboard,
+            },
+        });
     }
 }
 

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

@@ -10,7 +10,7 @@ export declare class PageMonitor extends Singleton implements Monitor {
      */
     _onPageEventHandle(event: Event): void;
     /** Returns document state */
-    getDocumentState(): "hidden" | "active" | "passive";
+    getDocumentState(): "passive" | "hidden" | "active";
     /**
      * Returns object size in bytes
      * @param  {} obj

package/dist/monitors/PageMonitor.js

@@ -1,9 +1,29 @@
-import { PAGE_EVENTS_WINDOW, PAGE_EVENTS_DOCUMENT, PAGE_EVENT_TYPE } from '../constants.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
 import { EventDebouncer } from '../pageVisit/EventDebouncer.js';
 import { Singleton } from './BaseMonitor.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
 
 /** @module PageMonitor */
+const PAGE_EVENTS_DOCUMENT = ['visibilitychange', 'resume', 'freeze', 'readystatechange', 'cut', 'copy', 'paste'];
+// page events we track in the session
+// don't include beforeunload, it will affect bfcache
+const PAGE_EVENTS_WINDOW = [
+    'pagehide',
+    'pageshow',
+    'focus',
+    'blur',
+    'popstate',
+    'online',
+    'offline',
+    'messageerror',
+    'languagechange',
+    'hashchange',
+    'beforeprint',
+    'afterprint',
+    'load',
+    'resize',
+];
 /** Monitors the page events which we capture and later process */
 class PageMonitor extends Singleton {
     /** Starts monitoring page events on the document */
@@ -65,7 +85,10 @@ class PageMonitor extends Singleton {
             // do nothing
         }
         // storing the page event in the page visit queue
-        EventDebouncer.getInstance().addEvent(payload, PAGE_EVENT_TYPE);
+        EventDebouncer.getInstance().debounce({
+            type: EventType.Page,
+            page: payload,
+        });
     }
     /** Returns document state */
     getDocumentState() {

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

@@ -1,9 +1,5 @@
-/** @module RequestMonitor */
-import 'react-native/Libraries/Network/fetch';
 import { Monitor, Singleton } from './BaseMonitor';
-/**
- * Monitors all requests
- */
+/** Monitors all requests */
 export default class RequestMonitor extends Singleton implements Monitor {
     /** main method */
     monitor(): void;
@@ -15,54 +11,38 @@ export default class RequestMonitor extends Singleton implements Monitor {
      * thus client code may throw an error.
      */
     private static consumeResponseAndGetBodyText;
-    /**
-     * Generates new PVEventHTTP
-     */
+    /** Generates new PVEventHTTP */
     private static getPvEventHttp;
-    /**
-     * Gets headers from request or request options. Handles different scenarios where simple conversion is not possible
-     */
+    /** Gets headers from request or request options. Handles different scenarios where simple conversion is not possible */
     private static getRequestHeaders;
     /**
      * Gets response headers.
      * It is always a Headers object.
      */
     private static getResponseHeaders;
-    /**
-     * Gets request body from body strings or Request options
-     */
+    /** Gets request body from body strings or Request options */
     private static getRequestBody;
-    /**
-     * Returns the parameters to pass the PageVisitEventHTTP constructor. Specific to the fetch wrapper.
-     */
+    /** Returns the parameters to pass the HttpEventManager constructor. Specific to the fetch wrapper. */
     private static getHttpDataFromFetch;
     /** Clones Response / Request or returns original object if cloning is not possible */
     private static cloneResponse;
-    /**
-     * Handles fetch response safely. Reports PageVisitEventHTTP and error to Pagevisit if needed.
-     */
+    /** Handles fetch response safely. Reports HttpEventManager and error to Pagevisit if needed. */
     private static safeHandleFetchResponse;
-    /**
-     * Safe function to get method and url from fetch args
-     */
+    /** Safe function to get method and url from fetch args */
     private static getMethodUrlFromFetchArgs;
     /**
      * Setting up the wrapper around fetch functions to try and
      * catch http errors
      */
     private static setupGlobalFetchWrapper;
-    /**
-     * Does a check if data collection is enabled and combines it into HttpDataBundle
-     */
+    /** Does a check if data collection is enabled and combines it into HttpDataBundle */
     private static getHttpDataFromXhr;
     /**
      * on loadend we catch the event and
      * make sure it was correct
      */
     private static loadendHandler;
-    /**
-     * Handles fetch failure
-     */
+    /** Handles fetch failure */
     private static handleFetchFailure;
     /** gets method from xhr */
     private static getMethodFromXHR;

package/dist/monitors/RequestMonitor.js

@@ -1,10 +1,8 @@
 import { __awaiter } from 'tslib';
-import 'react-native/Libraries/Network/fetch';
 import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
-import { isHttpCodeFailure, PageVisitEventHTTP } from '../pageVisit/pageVisitEventHTTP.js';
+import { isHttpCodeFailure, saveHTTPEvent } from '../pageVisit/HttpEventManager.js';
 import { safeEntries, propWriteableOrMadeWriteable, replace } from '../utils/object.js';
-import { BODY_USED_ERROR, HTTP_RESP_LENGTH_ATT_NAME, SEVERITY, PV_SEQ_ATT_NAME, RESPONSE_ERROR_TYPE, GQL_ERROR_TYPE, XML_HTTP_REQUEST_ERROR_TYPE, FETCH_EXCEPTION_ERROR_TYPE, HTTP_METHOD_ATT_NAME, HTTP_RESP_CODE_ATT_NAME, URL_ATT_NAME, HTTP_RESP_TIME_ATT_NAME } from '../constants.js';
-import ClientConfig from '../api/clientConfig.js';
+import ClientConfig from '../api/ClientConfig.js';
 import { noibuLog } from '../utils/log.js';
 import { tryGetStackTrace, safeTrim } from '../utils/function.js';
 import { promiseAll } from '../utils/polyfills.js';
@@ -12,10 +10,13 @@ import { addSafeEventListener } from '../utils/eventlistener.js';
 import { HTTPDataBundler } from './http-tools/HTTPDataBundler.js';
 import GqlErrorValidator from './http-tools/GqlErrorValidator.js';
 import { Singleton } from './BaseMonitor.js';
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { Severity } from '../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
+import { PageVisitErrorSource } from '../node_modules/@noibu/metroplex-ts-bindings/dist/PageVisitErrorSource.js';
 
-/**
- * Monitors all requests
- */
+/** request monitor */
+const BODY_USED_ERROR = 'Response data unavailable due to an improperly wrapped fetch call';
+/** Monitors all requests */
 class RequestMonitor extends Singleton {
     /** main method */
     monitor() {
@@ -42,27 +43,23 @@ class RequestMonitor extends Singleton {
             return response.text();
         });
     }
-    /**
-     * Generates new PVEventHTTP
-     */
+    /** Generates new PVEventHTTP */
     static getPvEventHttp(status, responseHeaders, method, url, responseTime) {
         const httpEvent = {
-            [HTTP_METHOD_ATT_NAME]: method,
-            [HTTP_RESP_CODE_ATT_NAME]: status,
-            [URL_ATT_NAME]: url,
-            [HTTP_RESP_TIME_ATT_NAME]: responseTime,
+            mtd: method,
+            code: status,
+            url,
+            r_time: responseTime,
         };
         const bundler = HTTPDataBundler.getInstance();
         // add response payload length, if any
         const contentLength = bundler.contentLength(responseHeaders);
         if (contentLength > 0 && bundler.shouldContinueForURL(url)) {
-            httpEvent[HTTP_RESP_LENGTH_ATT_NAME] = contentLength;
+            httpEvent.resp_len = contentLength;
         }
         return httpEvent;
     }
-    /**
-     * Gets headers from request or request options. Handles different scenarios where simple conversion is not possible
-     */
+    /** Gets headers from request or request options. Handles different scenarios where simple conversion is not possible */
     static getRequestHeaders(request, options) {
         const headers = safeEntries((request === null || request === void 0 ? void 0 : request.headers) || (options === null || options === void 0 ? void 0 : options.headers));
         return HTTPDataBundler.headersMapFromIterable(headers);
@@ -75,9 +72,7 @@ class RequestMonitor extends Singleton {
         const headers = safeEntries(response === null || response === void 0 ? void 0 : response.headers);
         return HTTPDataBundler.headersMapFromIterable(headers);
     }
-    /**
-     * Gets request body from body strings or Request options
-     */
+    /** Gets request body from body strings or Request options */
     static getRequestBody(requestText, options) {
         if (typeof requestText === 'string') {
             return requestText;
@@ -85,9 +80,7 @@ class RequestMonitor extends Singleton {
         // it's fine if it's falsy or an empty string, we catch that in HTTPDataBundler.getInstance().bundleHTTPData
         return options === null || options === void 0 ? void 0 : options.body;
     }
-    /**
-     * Returns the parameters to pass the PageVisitEventHTTP constructor. Specific to the fetch wrapper.
-     */
+    /** Returns the parameters to pass the HttpEventManager constructor. Specific to the fetch wrapper. */
     static getHttpDataFromFetch(request, response, method, url, options, isError, requestText, responseText) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
@@ -103,17 +96,15 @@ class RequestMonitor extends Singleton {
         }
         return ogResponse; // body consumed already, no http response body for us
     }
-    /**
-     * Handles fetch response safely. Reports PageVisitEventHTTP and error to Pagevisit if needed.
-     */
+    /** Handles fetch response safely. Reports HttpEventManager and error to Pagevisit if needed. */
     static safeHandleFetchResponse(startTime, url, method, options, request) {
         return (ogResponse) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a;
             try {
                 if (!ogResponse) {
                     // no idea how, but this happens sometimes, esp if other libs override fetch
                     // logging to track the issue if it becomes widespread
-                    return ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in custom fetch() callback: no response received`, false, SEVERITY.error);
+                    return ClientConfig.getInstance().postInternalError({ msg: 'No response object in fetch callback', url, method, options, request }, false, Severity.ERROR);
                 }
                 const clonedResponse = RequestMonitor.cloneResponse(ogResponse); // have to do it as early as possible
                 const graphqlResponse = RequestMonitor.cloneResponse(clonedResponse); // and two times more for each consumption
@@ -129,15 +120,17 @@ class RequestMonitor extends Singleton {
                 ]);
                 const httpEvent = RequestMonitor.getPvEventHttp(status, headers, method, url, respTime);
                 const httpData = yield RequestMonitor.getHttpDataFromFetch(request, httpEventDataResponse, method, url, options, isHttpError || !!gqlError, maybeRequestText, responseText);
-                const pageVisitEventHTTP = new PageVisitEventHTTP(httpEvent, httpData, !!gqlError);
-                pageVisitEventHTTP.saveHTTPEvent();
-                const seq = (_b = pageVisitEventHTTP.httpData) === null || _b === void 0 ? void 0 : _b[PV_SEQ_ATT_NAME];
+                const seq = saveHTTPEvent(httpEvent, httpData, !!gqlError);
                 if (isHttpError) {
                     // this does not consume response body so no need to clone it
-                    saveErrorToPagevisit(RESPONSE_ERROR_TYPE, clonedResponse, seq);
+                    saveErrorToPagevisit(Object.assign(Object.assign({}, clonedResponse), { type: PageVisitErrorSource.Response }), seq);
                 }
                 if (gqlError) {
-                    gqlError.forEach(error => saveErrorToPagevisit(GQL_ERROR_TYPE, error, seq));
+                    gqlError.forEach(error => saveErrorToPagevisit({
+                        url: ClientConfig.getInstance().globalUrl,
+                        gql_err: error,
+                        type: PageVisitErrorSource.Response,
+                    }, seq));
                 }
             }
             catch (e) {
@@ -146,13 +139,11 @@ class RequestMonitor extends Singleton {
                     return;
                 }
                 const stack = tryGetStackTrace(e);
-                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in custom fetch() callback: ${e}${stack}`, false, SEVERITY.error);
+                ClientConfig.getInstance().postInternalError({ msg: `Error in custom fetch() callback`, error: e, stack }, false, Severity.ERROR);
             }
         });
     }
-    /**
-     * Safe function to get method and url from fetch args
-     */
+    /** Safe function to get method and url from fetch args */
     static getMethodUrlFromFetchArgs(resource, options) {
         const defaultResource = { method: 'GET', url: '' };
         try {
@@ -170,7 +161,7 @@ class RequestMonitor extends Singleton {
             };
         }
         catch (e) {
-            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in fetch() wrapper: ${e}`, false, SEVERITY.error);
+            ClientConfig.getInstance().postInternalError({ msg: `Error in fetch() wrapper`, error: e }, false, Severity.ERROR);
         }
         return defaultResource;
     }
@@ -206,9 +197,7 @@ class RequestMonitor extends Singleton {
             };
         });
     }
-    /**
-     * Does a check if data collection is enabled and combines it into HttpDataBundle
-     */
+    /** Does a check if data collection is enabled and combines it into HttpDataBundle */
     static getHttpDataFromXhr(xhrObj_1, method_1, url_1, isError_1) {
         return __awaiter(this, arguments, void 0, function* (xhrObj, method, url, isError, requestPayload = null, responseText) {
             if (!HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
@@ -224,28 +213,27 @@ class RequestMonitor extends Singleton {
      */
     static loadendHandler(xhr, startTime, url, method, requestPayload) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const respTime = Date.now() - startTime;
             const gqlError = yield GqlErrorValidator.fromXhr(url, xhr);
             const httpError = isHttpCodeFailure(xhr.status);
             const responseText = yield HTTPDataBundler.getResponseStringFromXHR(xhr);
             const httpEvent = RequestMonitor.getPvEventHttp(xhr.status, HTTPDataBundler.headersMapFromString(xhr.getAllResponseHeaders()), method, url, respTime);
             const httpData = yield RequestMonitor.getHttpDataFromXhr(xhr, method, url, httpError || !!gqlError, requestPayload, responseText);
-            const pageVisitEventHTTP = new PageVisitEventHTTP(httpEvent, httpData, !!gqlError);
             // Save HTTP Info
-            pageVisitEventHTTP.saveHTTPEvent();
-            const seq = (_a = pageVisitEventHTTP.httpData) === null || _a === void 0 ? void 0 : _a[PV_SEQ_ATT_NAME];
+            const seq = saveHTTPEvent(httpEvent, httpData, !!gqlError);
             if (httpError) {
-                saveErrorToPagevisit(XML_HTTP_REQUEST_ERROR_TYPE, xhr, seq);
+                saveErrorToPagevisit({ url: xhr.responseURL, status: xhr.status, type: PageVisitErrorSource.XMLHttpRequest }, seq);
             }
             if (gqlError) {
-                gqlError.forEach(error => saveErrorToPagevisit(GQL_ERROR_TYPE, error, seq));
+                gqlError.forEach(error => saveErrorToPagevisit({
+                    url: ClientConfig.getInstance().globalUrl,
+                    gql_err: error,
+                    type: PageVisitErrorSource.Response,
+                }, seq));
             }
         });
     }
-    /**
-     * Handles fetch failure
-     */
+    /** Handles fetch failure */
     static handleFetchFailure(maybeErr, url) {
         if (!maybeErr || typeof maybeErr !== 'object') {
             return;
@@ -263,8 +251,9 @@ class RequestMonitor extends Singleton {
         errorFromFetch.message = `${err.message}${urlMessage}`;
         const errorPayload = {
             error: errorFromFetch,
+            type: PageVisitErrorSource.FetchException,
         };
-        saveErrorToPagevisit(FETCH_EXCEPTION_ERROR_TYPE, errorPayload);
+        saveErrorToPagevisit(errorPayload);
     }
     /** gets method from xhr */
     static getMethodFromXHR(xhr, payload) {
@@ -292,7 +281,7 @@ class RequestMonitor extends Singleton {
                 }
                 catch (e) {
                     const stack = tryGetStackTrace(e);
-                    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in XHR.send() wrapper: ${e}${stack}`, false, SEVERITY.error);
+                    ClientConfig.getInstance().postInternalError({ msg: `Error in XHR.send() wrapper`, error: e, stack }, false, Severity.ERROR);
                 }
                 return originalFunction.call(this, payload);
             };
@@ -310,14 +299,14 @@ class RequestMonitor extends Singleton {
                 try {
                     /**
                      * We wrap assignment of the .noibu[...] variables in a try/catch, as we're assigning
-                     * properties to a built-in object type, and have no guarantee of success.
+                     * properties to a built-in object source, and have no guarantee of success.
                      */
                     try {
                         this.noibuHttpMethod = method;
                         this.noibuHttpUrl = url;
                     }
                     catch (error) {
-                        ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Unable to set custom properties on XHR object: ${error}`, false, SEVERITY.warn);
+                        ClientConfig.getInstance().postInternalError({ msg: `Unable to set custom properties on XHR object`, error }, false, Severity.WARN);
                     }
                     if (shouldHandleLoadend) {
                         const startTime = Date.now();
@@ -326,7 +315,7 @@ class RequestMonitor extends Singleton {
                 }
                 catch (e) {
                     const stack = tryGetStackTrace(e);
-                    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in XHR.open() wrapper: ${e}${stack}`, false, SEVERITY.error);
+                    ClientConfig.getInstance().postInternalError({ msg: `Error in XHR.open() wrapper`, error: e, stack }, false, Severity.ERROR);
                 }
                 return originalFunction.call(this, method, url, async, user, password);
             };
@@ -353,7 +342,7 @@ class RequestMonitor extends Singleton {
                     }
                 }
                 catch (error) {
-                    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in XHR.setRequestHeader() wrapper: ${error}`, false, SEVERITY.error);
+                    ClientConfig.getInstance().postInternalError({ msg: `Error in XHR.setRequestHeader() wrapper`, error }, false, Severity.ERROR);
                 }
                 return originalFunction.call(this, header, value);
             };

package/dist/monitors/http-tools/GqlErrorValidator.d.ts

@@ -0,0 +1,35 @@
+import { GQLError } from '@noibu/metroplex-ts-bindings';
+/** Try detecting GraphQL errors from http response */
+export default class GqlErrorValidator {
+    /** Retrieves GQL error object based on fetch request/response */
+    static fromFetch(url: string, options: RequestInit | undefined, request: Request | undefined, response: Response): Promise<GQLError[] | null>;
+    /** Retrieves GQL error object based on XHR object */
+    static fromXhr(url: string, xhr: unknown): Promise<GQLError[] | null>;
+    /** Try safely parse a string and return null if fails */
+    static _parseJsonSafely(content: string): any;
+    /** Try to get content type for fetch arguments */
+    static _getContentTypeFromFetchArguments(options?: RequestInit, request?: Request): string | null;
+    /**
+     * Checks if request is aborted
+     * If it has been aborted we are not able to consume the response
+     */
+    static _isRequestAborted(options?: RequestInit, request?: RequestInit): boolean | null | undefined;
+    /** Determines if request should be processed */
+    static _shouldHandleRequest(url: string, contentType?: string | null): boolean;
+    /** Sanitizes payload object */
+    static _validate(data: unknown, validationIssues: string[]): GQLError[] | null;
+    /** Sanitizes message object */
+    static _validateMessage(error: GQLError): void;
+    /**
+     * Sanitizes extensions object
+     */
+    static _validateExtensions(error: GQLError): void;
+    /** Sanitizes locations object */
+    static _validateLocations(error: GQLError, validationIssues: string[]): void;
+    /** Sanitizes path object */
+    static _validatePath(error: object, validationIssues: string[]): void;
+    /** Posts error */
+    static _postError(message: unknown): void;
+    /** Posts issue found during object sanitization */
+    static _postValidationIssues(validationIssues: string[]): void;
+}