noibu-react-native 0.2.6 → 0.2.8

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

@@ -1,24 +1,22 @@
 import { __awaiter } from 'tslib';
 import { isInstanceOf, getMaxSubstringAllowed } from '../../utils/function.js';
-import { CONTENT_TYPE, SEVERITY } from '../../constants.js';
-import ClientConfig from '../../api/clientConfig.js';
+import { CONTENT_TYPE } from '../../constants.js';
+import ClientConfig from '../../api/ClientConfig.js';
+import '../../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { Severity } from '../../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.js';
 
-const MESSAGE_ATT_NAME = 'message';
-const EXTENSIONS_ATT_NAME = 'extensions';
-const LOCATIONS_ATT_NAME = 'locations';
-const PATH_ATT_NAME = 'path';
-const LINE_ATT_NAME = 'line';
-const COLUMN_ATT_NAME = 'column';
+const GQL_EXTENSIONS_ATT_NAME = 'extensions';
+const GQL_LOCATIONS_ATT_NAME = 'locations';
+const GQL_PATH_ATT_NAME = 'path';
+const GQL_LINE_ATT_NAME = 'line';
+const GQL_COLUMN_ATT_NAME = 'column';
+const GQL_MESSAGE_ATT_NAME = 'message';
 const MESSAGE_MAX_LENGTH = 1000;
 /* eslint-disable no-restricted-syntax */
 /* eslint-disable no-param-reassign */
-/**
- * Try detecting GraphQL errors from http response
- */
+/** Try detecting GraphQL errors from http response */
 class GqlErrorValidator {
-    /**
-     * Retrieves GQL error object based on fetch request/response
-     */
+    /** Retrieves GQL error object based on fetch request/response */
     static fromFetch(url, options, request, response) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -42,15 +40,11 @@ class GqlErrorValidator {
             return null;
         });
     }
-    /**
-     * Retrieves GQL error object based on XHR object
-     */
+    /** Retrieves GQL error object based on XHR object */
     static fromXhr(url, xhr) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const isResponseValid = isInstanceOf(xhr, XMLHttpRequest) &&
-                    xhr.status >= 200 &&
-                    xhr.status <= 299;
+                const isResponseValid = isInstanceOf(xhr, XMLHttpRequest) && xhr.status >= 200 && xhr.status <= 299;
                 if (!isResponseValid) {
                     return null;
                 }
@@ -84,9 +78,7 @@ class GqlErrorValidator {
             return null;
         });
     }
-    /**
-     * Try safely parse a string and return null if fails
-     */
+    /** Try safely parse a string and return null if fails */
     static _parseJsonSafely(content) {
         try {
             return JSON.parse(content);
@@ -95,9 +87,7 @@ class GqlErrorValidator {
             return null;
         }
     }
-    /**
-     * Try to get content type for fetch arguments
-     */
+    /** Try to get content type for fetch arguments */
     static _getContentTypeFromFetchArguments(options, request) {
         let headers = null;
         if (isInstanceOf(request, Request)) {
@@ -125,9 +115,7 @@ class GqlErrorValidator {
         }
         return false;
     }
-    /**
-     * Determines if request should be processed
-     */
+    /** Determines if request should be processed */
     static _shouldHandleRequest(url, contentType) {
         if (contentType) {
             contentType = contentType.toLowerCase();
@@ -139,36 +127,31 @@ class GqlErrorValidator {
             }
             isGqlUrl = url.toLowerCase().includes('graphql');
         }
-        return ((contentType === 'application/json' && isGqlUrl) ||
-            contentType === 'application/graphql');
+        return (contentType === 'application/json' && isGqlUrl) || contentType === 'application/graphql';
     }
-    /**
-     * Sanitizes payload object
-     */
+    /** Sanitizes payload object */
     static _validate(data, validationIssues) {
-        if (!(typeof data === 'object' &&
-            data &&
-            Array.isArray(data.errors))) {
+        if (!(typeof data === 'object' && data && Array.isArray(data.errors))) {
             return null;
         }
         const errors = data.errors;
-        errors.forEach(error => {
+        errors.forEach((error) => {
             if (typeof error !== 'object' || !error) {
                 return;
             }
             const properties = Object.keys(error);
             for (const property of properties) {
                 switch (property) {
-                    case MESSAGE_ATT_NAME:
+                    case GQL_MESSAGE_ATT_NAME:
                         this._validateMessage(error);
                         break;
-                    case LOCATIONS_ATT_NAME:
+                    case GQL_LOCATIONS_ATT_NAME:
                         this._validateLocations(error, validationIssues);
                         break;
-                    case PATH_ATT_NAME:
+                    case GQL_PATH_ATT_NAME:
                         this._validatePath(error, validationIssues);
                         break;
-                    case EXTENSIONS_ATT_NAME:
+                    case GQL_EXTENSIONS_ATT_NAME:
                         this._validateExtensions(error);
                         break;
                     default:
@@ -183,32 +166,27 @@ class GqlErrorValidator {
         }
         return errors;
     }
-    /**
-     * Sanitizes message object
-     */
+    /** Sanitizes message object */
     static _validateMessage(error) {
-        error[MESSAGE_ATT_NAME] = getMaxSubstringAllowed(error[MESSAGE_ATT_NAME], MESSAGE_MAX_LENGTH);
+        error[GQL_MESSAGE_ATT_NAME] = getMaxSubstringAllowed(error[GQL_MESSAGE_ATT_NAME], MESSAGE_MAX_LENGTH);
     }
     /**
      * Sanitizes extensions object
-     * @param {any} error
      */
     static _validateExtensions(error) {
-        const json = JSON.stringify(error[EXTENSIONS_ATT_NAME]);
-        error[EXTENSIONS_ATT_NAME] = getMaxSubstringAllowed(json, MESSAGE_MAX_LENGTH);
+        const json = JSON.stringify(error[GQL_EXTENSIONS_ATT_NAME]);
+        error[GQL_EXTENSIONS_ATT_NAME] = getMaxSubstringAllowed(json, MESSAGE_MAX_LENGTH);
     }
-    /**
-     * Sanitizes locations object
-     */
+    /** Sanitizes locations object */
     static _validateLocations(error, validationIssues) {
-        const locations = error[LOCATIONS_ATT_NAME];
+        const locations = error[GQL_LOCATIONS_ATT_NAME];
         if (Array.isArray(locations)) {
             for (const location of locations) {
                 const properties = Object.keys(location);
                 for (const property of properties) {
                     switch (property) {
-                        case LINE_ATT_NAME:
-                        case COLUMN_ATT_NAME:
+                        case GQL_LINE_ATT_NAME:
+                        case GQL_COLUMN_ATT_NAME:
                             if (!Number.isSafeInteger(location[property])) {
                                 const value = location[property];
                                 location[property] = 0;
@@ -224,35 +202,29 @@ class GqlErrorValidator {
             }
         }
         else {
-            delete error[LOCATIONS_ATT_NAME];
+            delete error[GQL_LOCATIONS_ATT_NAME];
             validationIssues.push(`unexpected error.locations`);
         }
     }
-    /**
-     * Sanitizes path object
-     */
+    /** Sanitizes path object */
     static _validatePath(error, validationIssues) {
-        const path = error[PATH_ATT_NAME];
+        const path = error[GQL_PATH_ATT_NAME];
         if (Array.isArray(path)) {
-            error[PATH_ATT_NAME] = error[PATH_ATT_NAME].map(x => x.toString());
+            error[GQL_PATH_ATT_NAME] = error[GQL_PATH_ATT_NAME].map(x => x.toString());
         }
         else {
-            delete error[PATH_ATT_NAME];
+            delete error[GQL_PATH_ATT_NAME];
             validationIssues.push(`unexpected error.path`);
         }
     }
-    /**
-     * Posts error
-     */
+    /** Posts error */
     static _postError(message) {
-        ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`GQL parse error: ${message}`, false, SEVERITY.error);
+        ClientConfig.getInstance().postInternalError({ msg: `GQL parse error: ${message}` }, false, Severity.ERROR);
     }
-    /**
-     * Posts issue found during object sanitization
-     */
+    /** Posts issue found during object sanitization */
     static _postValidationIssues(validationIssues) {
         const message = validationIssues.join(',');
-        ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`GQL error validation warning: ${message}`, false, SEVERITY.error);
+        ClientConfig.getInstance().postInternalError({ msg: `GQL error validation warning: ${message}` }, false, Severity.ERROR);
     }
 }
 

package/dist/{src/monitors → monitors}/http-tools/HTTPDataBundler.d.ts

@@ -1,6 +1,6 @@
-import { WrappedXMLHttpRequest } from '../../../types/WrappedObjects';
-import { HTTPDataBundle } from '../../../types/PageVisitEvents.types';
 import { Singleton } from '../BaseMonitor';
+import { NoSeq } from '../../types/Metroplex';
+import { RawHttpData } from '@noibu/metroplex-ts-bindings';
 /** Bundles HTTP payloads and headers */
 export declare class HTTPDataBundler extends Singleton {
     contentTypeReadableRegex: RegExp;
@@ -9,13 +9,11 @@ export declare class HTTPDataBundler extends Singleton {
     httpDataCollectionEnabled: boolean;
     httpDataAllowedRelativeRegex: RegExp | null;
     httpDataAllowedAbsoluteRegex: RegExp | null;
-    /**
-     * Creates an instance of the ClickMonitor instance
-     */
+    /** Creates an instance of the ClickMonitor instance */
     constructor();
     /**
      * 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
      */
@@ -41,15 +39,13 @@ export declare class HTTPDataBundler extends Singleton {
      * @returns a string representation of the response, or null if this fails.
      */
     static getResponseStringFromXHR(xhr: WrappedXMLHttpRequest): Promise<any>;
-    /**
-     * Builds an HTTP Data bundle
-     */
-    bundleHTTPData(url: string, requestHeaders: Map<string, string> | undefined, rawRequestPayload: any, responseHeaders: Map<string, string>, rawResponsePayload: any, method: string, isError: boolean): HTTPDataBundle | null;
+    /** Builds an HTTP Data bundle */
+    bundleHTTPData(url: string, rawRequestHeaders: Map<string, string> | undefined, rawRequestPayload: any, rawResponseHeaders: Map<string, string>, rawResponsePayload: any, method: string, isError: boolean): NoSeq<RawHttpData> | null;
     /**
      * Validates a request based on the URL and method. When enabled, will handle
      * de-duping the requests
      */
-    isValidRequest(method: unknown): boolean;
+    isValidRequest(method: unknown): unknown;
     /**
      * Checks two things: that the URL is either on the same domain (or an address relative to the
      * current domain), and also checks that the config http_data_collection flag is enabled.
@@ -67,18 +63,16 @@ export declare class HTTPDataBundler extends Singleton {
      * Checks whether HTTP payloads can be collected on this URL
      * returns boolean indicating whether HTTP payloads can be collected on this URL
      */
-    shouldCollectPayloadForURL(url: any): boolean;
+    shouldCollectPayloadForURL(url: any): boolean | undefined;
     /**
      * Double checks content length if we couldn't read the headers, and redacts PII
      * returns the restricted payload
      */
-    restrictPayload(payload: string, url: string, isError: boolean): string;
+    restrictPayload(payload: unknown, url: string, isError: boolean): string;
     /**
      * 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: Map<string, string>, isError: boolean): boolean;
     /**

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

@@ -1,17 +1,47 @@
 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 { 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';
+import '../../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { Severity } from '../../node_modules/@noibu/metroplex-ts-bindings/dist/Severity.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 +62,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 +76,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 +167,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 +202,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 +220,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,28 +283,20 @@ 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);
+            }, false, Severity.ERROR);
             return HTTP_BODY_NULL_STRING;
         }
         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 +309,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 +325,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 +385,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 +430,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/ReactNativeNavigationIntegration.d.ts

@@ -0,0 +1,17 @@
+import { NavigationDelegate } from 'react-native-navigation/lib/dist/src/NavigationDelegate';
+import { Singleton } from '../BaseMonitor';
+/** react-native-navigation adapter */
+export declare class ReactNativeNavigationIntegration extends Singleton implements NavigationIntegration {
+    private stack;
+    private stackPointers;
+    private registration;
+    /** Attaches provided listeners to the integration */
+    register(navigation: NavigationDelegate, onNavigation: (breadcrumbs: string[]) => void): void;
+    /**
+     * Listens to ComponentWillAppear events, keeps track of visited screens and
+     * pops them if the same page is visited to prevent cycles
+     */
+    private getListener;
+    /** Destructor */
+    protected destroy(): void;
+}

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/{src/pageVisit → pageVisit}/EventDebouncer.d.ts

@@ -1,24 +1,23 @@
 import { Singleton } from '../monitors/BaseMonitor';
+import { EventType, PageVisitEvent, UserStepType } from '@noibu/metroplex-ts-bindings';
 /**
  * Singleton class responsible for debouncing all events
  * that are registered
  */
 export declare class EventDebouncer extends Singleton {
-    private readonly eventsToDebounce;
-    /**
-     * Creates an instance of EventDebouncer
-     */
+    private readonly debouncePeriods;
+    private readonly timeouts;
+    private readonly events;
+    /** Creates an instance of EventDebouncer */
     constructor();
     /**
      * 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: any, type: keyof typeof this.eventsToDebounce, occurredAt?: number): void;
-    /**
-     * 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: string): void;
+    debounce(event: Omit<PageVisitEvent, 'occ_at'>): void;
+    /** Debounce function to be executed once the debounce period is completed */
+    sendEvents: (type: EventType | UserStepType) => void;
     /** Sets up the page hide handler to try to push remaining events in the queues */
     _setupUnloadHandler(): void;
+    protected destroy(): void;
 }