noibu-react-native 0.2.2 → 0.2.4

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

@@ -0,0 +1,458 @@
+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 { safeFromEntries, safeEntries } from '../../utils/object.js';
+import { safeTrim, stringifyJSON, isString } from '../../utils/function.js';
+import { removePII } from '../../utils/piiRedactor.js';
+import { Singleton } from '../../types/Monitor.js';
+
+/** Bundles HTTP payloads and headers */
+class HTTPDataBundler extends Singleton {
+    /**
+     * Creates an instance of the ClickMonitor instance
+     */
+    constructor() {
+        super();
+        // compile regex only once
+        this.contentTypeReadableRegex = new RegExp(HUMAN_READABLE_CONTENT_TYPE_REGEX, 'i');
+        // pull out the domain hostname
+        const initialURL = ClientConfig.getInstance().globalUrl;
+        this.initialURLPartsReversed = [];
+        this.hostname = '';
+        if (initialURL && initialURL.length > 0) {
+            try {
+                // Store URL parts to class variable
+                this.hostname = new URL(initialURL).hostname;
+                this.initialURLPartsReversed = this.hostname.split('.');
+                // Remove www. etc.
+                // eslint-disable-next-line no-unused-expressions
+                DEFAULT_WEBSITE_SUBDOMAIN_PATTERN.test(this.initialURLPartsReversed[0]) && this.initialURLPartsReversed.shift();
+                // Reverse array
+                this.initialURLPartsReversed.reverse();
+            }
+            catch (e) {
+                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Unable to determine hostname for initial URL: ${e}`, false, SEVERITY.warn);
+            }
+        }
+        this.httpDataCollectionEnabled =
+            !!ClientConfig.getInstance().enableHttpDataCollection;
+        // compile the relative and full HTTP URL regexes
+        const allowedURLs = ClientConfig.getInstance().listOfUrlsToCollectHttpDataFrom;
+        this.httpDataAllowedAbsoluteRegex = HTTPDataBundler.buildAllowedRegex(allowedURLs, true);
+        this.httpDataAllowedRelativeRegex = HTTPDataBundler.buildAllowedRegex(allowedURLs, false);
+        // track unique requests and only capture each once
+        // TODO: disabled for beta. NOI-4253
+        // this.uniqueRequests = new Set();
+    }
+    /**
+     * Builds the HTTP payload allowed regexes for full and relative URLs
+     * @param allowedURLs A list of allowed URLs
+     * @param absolute Use only absolute URLs if true, use only relative URL if false
+     * @returns a regex of allowed URLs
+     */
+    static buildAllowedRegex(allowedURLs, absolute) {
+        if (!allowedURLs || !Array.isArray(allowedURLs))
+            return null;
+        const allowedURLsFiltered = allowedURLs
+            .map(url => safeTrim(url).toLowerCase())
+            .filter(url => {
+            const isAbsolute = HTTPDataBundler.isAbsoluteURL(url);
+            if (absolute) {
+                return url && isAbsolute;
+            }
+            return url && !isAbsolute;
+        });
+        if (allowedURLsFiltered.length > 0) {
+            return new RegExp(allowedURLsFiltered.join('|'));
+        }
+        return null;
+    }
+    /**
+     * Takes an iterator and returns a map of strings representing headers.
+     * param {object} headersIterable any iterable object
+     * returns a map of strings (as expected by metroplex) representing HTTP
+     * request or response headers
+     */
+    static headersMapFromIterable(headersIterable) {
+        const headerMap = new Map();
+        for (const header of headersIterable) {
+            // Ensure we're working with strings
+            // This will also automatically convert null to "null"
+            if (typeof header[0] !== 'string')
+                header[0] = String(header[0]);
+            if (typeof header[1] !== 'string')
+                header[1] = String(header[1]);
+            headerMap.set(header[0].toLowerCase(), header[1]);
+        }
+        return headerMap;
+    }
+    /**
+     * Takes a string of headers with 'name: value' and returns
+     * a map of strings representing headers.
+     * headersString is all the headers in one string
+     * returns a map of strings (as expected by metroplex) representing HTTP
+     * request or response headers
+     */
+    static headersMapFromString(headersString) {
+        const headerMap = new Map();
+        if (!headersString || typeof headersString !== 'string')
+            return headerMap;
+        const headerStringArray = headersString.split('\r\n').filter(Boolean);
+        headerStringArray.forEach(function (headerString) {
+            const split = headerString.split(': ');
+            if (split.length === 2 && split[0].length > 0 && split[1].length > 0) {
+                headerMap.set(split[0].toLowerCase(), split[1]);
+            }
+        });
+        return headerMap;
+    }
+    /**
+     * For an XHR object, checks the responseType property and handles the response or
+     * responseText property accordingly to return a string representation of the response.
+     * @returns a string representation of the response, or null if this fails.
+     */
+    static getResponseStringFromXHR(xhr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // This should not happen, as this function is called from a method on xhr.
+            if (!xhr)
+                return null;
+            if (xhr.responseType === '' || xhr.responseType === 'text') {
+                return xhr.responseText;
+            }
+            // If the XHR object exists but the response is null, return null as a string.
+            if (!xhr.response)
+                return HTTP_BODY_NULL_STRING;
+            if ((_a = xhr.response.documentElement) === null || _a === void 0 ? void 0 : _a.innerHTML) {
+                return xhr.response.documentElement.innerHTML;
+            }
+            if (typeof xhr.response.text === 'function') {
+                return yield xhr.response.text();
+            }
+            if (xhr.responseType === 'json') {
+                try {
+                    const text = stringifyJSON(xhr.response);
+                    if (text === '{}')
+                        return null; // stringifyJSON returns {} of it fails to serialize a property
+                    return text;
+                }
+                catch (e) {
+                    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Unable to stringify JSON response: ${e}`, false, SEVERITY.warn);
+                    return null;
+                }
+            }
+            return null;
+        });
+    }
+    /**
+     * Builds an HTTP Data bundle
+     */
+    bundleHTTPData(url, requestHeaders, rawRequestPayload, responseHeaders, rawResponsePayload, method, isError) {
+        if (!this.isValidRequest(method)) {
+            return null;
+        }
+        // stringify payload if correct type and not too large
+        let requestPayload = '';
+        let responsePayload = '';
+        if (this.shouldCollectPayloadForURL(url)) {
+            requestPayload =
+                this.getReasonPayloadIsDropped(requestHeaders, isError) ||
+                    this.stringFromRequestBody(rawRequestPayload, requestHeaders);
+            responsePayload =
+                this.getReasonPayloadIsDropped(responseHeaders, isError) ||
+                    this.stringFromRequestBody(rawResponsePayload, responseHeaders);
+        }
+        // don't bundle if there is no data
+        const safeRequestHeaders = requestHeaders || new Map();
+        const safeRequestPayload = requestPayload || '';
+        const safeResponseHeaders = responseHeaders || new Map();
+        const safeResponsePayload = responsePayload || '';
+        if (safeRequestHeaders.size === 0 &&
+            !safeRequestPayload &&
+            safeResponseHeaders.size === 0 &&
+            !safeResponsePayload) {
+            return null;
+        }
+        // Ensure payloads do not exceed the maximum size and redact PII
+        const requestPayloadUpdated = this.restrictPayload(safeRequestPayload, url, isError);
+        // Ensure payloads do not exceed the maximum size and redact PII
+        const responsePayloadUpdated = this.restrictPayload(safeResponsePayload, url, isError);
+        // Redact PII.
+        const cleanRequestHeaders = safeFromEntries(this.removePIIHeaders(requestHeaders));
+        const cleanResponseHeaders = safeFromEntries(this.removePIIHeaders(responseHeaders));
+        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,
+        };
+    }
+    /**
+     * Validates a request based on the URL and method. When enabled, will handle
+     * de-duping the requests
+     */
+    isValidRequest(method) {
+        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
+     * current domain), and also checks that the config http_data_collection flag is enabled.
+     * @param {string} url
+     * @returns boolean indicating whether the URL passed is either relative (in which case it is
+     * inherently on the current domain) or matches the current domain.
+     */
+    shouldContinueForURL(url) {
+        if (!this.httpDataCollectionEnabled)
+            return false;
+        if (!url || typeof url !== 'string' || !this.initialURLPartsReversed) {
+            return false;
+        }
+        // URL is absolute; either "http://example.com" or "//example.com"
+        if (HTTPDataBundler.isAbsoluteURL(url)) {
+            // Only capture requests on the same domain or in the allowed list
+            if (!this.shouldCollectPayloadForURL(url)) {
+                return false;
+            }
+        } // end `if` (if URL is relative, it is on the same domain.)
+        return true;
+    }
+    /**
+     * Determines if the URL is absolute or relative
+     * returns boolean indicating whether the URL passed is either absolute or relative
+     */
+    static isAbsoluteURL(url) {
+        if (!url || typeof url !== 'string') {
+            return false;
+        }
+        return url.indexOf('://') > 0 || url.indexOf('//') === 0;
+    }
+    /**
+     * Checks whether HTTP payloads can be collected on this URL
+     * returns boolean indicating whether HTTP payloads can be collected on this URL
+     */
+    shouldCollectPayloadForURL(url) {
+        var _a, _b;
+        if (!url || typeof url !== 'string') {
+            return false;
+        }
+        // check if in the full URL allowed list
+        const isAllowedAsAbsolute = (_a = this.httpDataAllowedAbsoluteRegex) === null || _a === void 0 ? void 0 : _a.test(url.toLowerCase());
+        const isRelative = !HTTPDataBundler.isAbsoluteURL(url);
+        // check if in the relative URL allowed list or if it is on the same domain
+        const isAllowedAsRelative = 
+        // if this is a relative URL (isURLSameDomain will fail) OR a full URL on domain
+        isRelative && ((_b = this.httpDataAllowedRelativeRegex) === null || _b === void 0 ? void 0 : _b.test(url.toLowerCase()));
+        return isAllowedAsAbsolute || isAllowedAsRelative;
+    }
+    /**
+     * Double checks content length if we couldn't read the headers, and redacts PII
+     * returns the restricted payload
+     */
+    restrictPayload(payload, url, isError) {
+        // if no payload, too large, payload already dropped,
+        // or payloads not allowed for this URL: nothing to do
+        if (!payload || !this.shouldCollectPayloadForURL(url)) {
+            return HTTP_BODY_NULL_STRING;
+        }
+        if (typeof payload !== 'string') {
+            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient({
+                msg: `restrictPayload received non string payload`,
+                payloadType: typeof payload,
+            }, 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.indexOf &&
+                (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;
+        }
+        if (payload.length > restrictSize) {
+            StoredMetrics.getInstance().addHttpDataDropByLength();
+            return `${HTTP_BODY_DROPPED_LENGTH_MSG} Payload length: ${payload.length}`;
+        }
+        // payload is good!
+        StoredMetrics.getInstance().addHttpDataPayloadCount();
+        return removePII(payload);
+    }
+    /**
+     * 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;
+        }
+        return this.contentLength(headers) <= restrictSize;
+    }
+    /**
+     * Returns true if the content type according to the headers is valid for collection.
+     * Also returns assumed true if content type is not stated in headers.
+     * @param {Map} headersMap
+     * @returns boolean true if acceptable to collect
+     */
+    contentTypeAcceptable(headersMap) {
+        // check content type
+        const contentType = headersMap.get(CONTENT_TYPE);
+        return !(contentType &&
+            !this.contentTypeReadableRegex.test(contentType.toLowerCase()));
+    }
+    /**
+     * Returns a descriptive string if we have to drop payload based on the length
+     * or type listed in the headers passed. Returns an empty string otherwise.
+     */
+    getReasonPayloadIsDropped(headers, isError) {
+        if (!(headers === null || headers === void 0 ? void 0 : headers.get)) {
+            return '';
+        }
+        const bundler = HTTPDataBundler.getInstance();
+        if (!bundler.contentTypeAcceptable(headers)) {
+            // not a readable request, drop the content
+            StoredMetrics.getInstance().addHttpDataDropByType();
+            return `${HTTP_BODY_DROPPED_TYPE_MSG} Payload type: ${headers.get(CONTENT_TYPE)}`;
+        }
+        if (!bundler.contentLengthAcceptable(headers, isError)) {
+            StoredMetrics.getInstance().addHttpDataDropByLength();
+            return `${HTTP_BODY_DROPPED_LENGTH_MSG} Payload length: ${bundler.contentLength(headers)}`;
+        }
+        return '';
+    }
+    /**
+     * Returns content length from the headers, if available.
+     * If headers are not found or length is not a number, return -1
+     */
+    contentLength(headersObject) {
+        if (!(headersObject === null || headersObject === void 0 ? void 0 : headersObject.get)) {
+            return 0;
+        }
+        // get content length
+        let contentLength = 0;
+        const contentValueString = headersObject.get(CONTENT_LENGTH);
+        if (!contentValueString) {
+            // no content length header found
+            return -1;
+        }
+        try {
+            contentLength = parseInt(contentValueString, 10);
+            if (Number.isNaN(contentLength)) {
+                // bad content length header
+                return -1;
+            }
+        }
+        catch (err) {
+            // if we can't convert the value to a number, confirm after reading payload
+            return -1;
+        }
+        return contentLength;
+    }
+    /**
+     * Accepts a value that could be any type used as a request payload,
+     * and returns a string representation, or null if this fails.
+     */
+    stringFromRequestBody(value, requestHeaders) {
+        /* eslint-disable no-param-reassign */
+        // Nullish check to ensure we don't send 'null' or 'undefined' as a string
+        if (value == null)
+            return null;
+        try {
+            if (isString(value) && requestHeaders instanceof Map) {
+                const contentType = requestHeaders.get(CONTENT_TYPE);
+                if (contentType &&
+                    contentType
+                        .toLowerCase()
+                        .includes('application/x-www-form-urlencoded')) {
+                    value = new URLSearchParams(value.toString());
+                }
+            }
+        }
+        catch (error) {
+            // Nothing--try next try block
+        }
+        try {
+            // If the payload is a FormData object, turn it into an object.
+            if (value instanceof FormData || value instanceof URLSearchParams) {
+                value = safeEntries(value).reduce((obj, [key, val]) => {
+                    obj[key] = this.stringFromRequestBody(val);
+                    return obj;
+                }, {});
+            }
+        }
+        catch (error) {
+            // Nothing--try next try block
+        }
+        try {
+            // Case where value has a .toString() method
+            const returnVal = value.toString();
+            // Catch case where .toString() is on an object, we don't want that --
+            // should be stringified below.
+            if (!returnVal.includes('[object'))
+                return returnVal;
+        }
+        catch (error) {
+            // Nothing--try next try block
+        }
+        try {
+            // Case where value is a Document type (HTML/XML)
+            return value.documentElement.innerHTML;
+        }
+        catch (error) {
+            // Nothing--try next try block
+        }
+        try {
+            // Case where value is any other object type
+            return stringifyJSON(value);
+        }
+        catch (e) {
+            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Unable to stringify request body: ${e}`, false, SEVERITY.warn);
+        }
+        return null;
+    }
+    /**
+     * Removes possible PII from headers.
+     * @param {Map} dirtyHeaders a Map of HTTP response or request headers
+     * @returns {Map|null} a map of headers with PII redacted
+     */
+    removePIIHeaders(dirtyHeaders) {
+        // In order to be fail-safe, let's return null if we won't be able to remove PII headers.
+        if (!(dirtyHeaders instanceof Map)) {
+            return null;
+        }
+        if (!dirtyHeaders.size) {
+            return dirtyHeaders;
+        }
+        const cleanHeaders = new Map(dirtyHeaders);
+        cleanHeaders.forEach((headerVal, headerKey, map) => {
+            // If the key is known PII, redact
+            if (BLOCKED_HTTP_HEADER_KEYS.includes(headerKey.toLowerCase())) {
+                map.set(headerKey, PII_REDACTION_REPLACEMENT_STRING);
+                // If not, run the header's value through the string redaction function
+            }
+            else {
+                map.set(headerKey, removePII(headerVal));
+            }
+        });
+        return cleanHeaders;
+    }
+}
+
+export { HTTPDataBundler };

package/dist/monitors/integrations/react-native-navigation-integration.js

@@ -2,8 +2,10 @@
  * react-native-navigation adapter
  */
 class ReactNativeNavigationIntegration {
-    stack = [];
-    stackPointers = {};
+    constructor() {
+        this.stack = [];
+        this.stackPointers = {};
+    }
     /**
      * attaches provided listeners to the integration
      */

package/dist/pageVisit/EventDebouncer.js

@@ -0,0 +1,99 @@
+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 { addSafeEventListener } from '../utils/eventlistener.js';
+import ClientConfig from '../api/clientConfig.js';
+import { Singleton } from '../types/Monitor.js';
+
+/** @module EventDebouncer */
+/**
+ * Singleton class responsible for debouncing all events
+ * that are registered
+ */
+class EventDebouncer extends Singleton {
+    /**
+     * 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._setupUnloadHandler();
+    }
+    /**
+     * 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);
+    }
+    /** 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);
+            });
+        });
+    }
+}
+
+export { EventDebouncer };

package/dist/pageVisit/pageVisitEventError.js

@@ -1,8 +1,8 @@
 import { isValidURL, getJSStack, stringifyJSON, getMaxSubstringAllowed, asString } from '../utils/function.js';
 import { EVENT_ERROR_TYPE, URL_ATT_NAME, BLOCKLISTED_DOMAINS, ERROR_EVENT_TYPE, ERROR_EVENT_ERROR_TYPE, CUSTOM_ERROR_EVENT_TYPE, ERROR_EVENT_UNHANDLED_REJECTION_TYPE, ERROR_LOG_EVENT_ERROR_TYPE, FETCH_EXCEPTION_ERROR_TYPE, WRAPPED_EXCEPTION_ERROR_TYPE, GQL_ERROR_TYPE, RESPONSE_ERROR_TYPE, XML_HTTP_REQUEST_ERROR_TYPE, ERROR_SOURCE_ATT_NAME, TYPE_ATT_NAME, JS_EVENT_TYPE, JS_ERROR_ATT_NAME, JS_STACK_FRAMES_ATT_NAME, JS_STACK_FILE_ATT_NAME, JS_STACK_METHOD_ATT_NAME, SEVERITY, JS_STACK_MESSAGE_ATT_NAME, HTTP_EVENT_TYPE, NOIBU_INPUT_URLS, HTTP_CODE_ATT_NAME, PV_SEQ_ATT_NAME, GQL_EVENT_TYPE, GQL_ERROR_ATT_NAME } from '../constants.js';
 import ClientConfig from '../api/clientConfig.js';
-import { InputMonitor } from '../monitors/inputMonitor.js';
 import StoredMetrics from '../api/storedMetrics.js';
+import { EventDebouncer } from './EventDebouncer.js';
 
 /** @module PageVisitEventError */
 
@@ -314,7 +314,7 @@ function saveErrorToPagevisit(type, payload, httpDataSeqNum) {
   // we register an error event
   StoredMetrics.getInstance().addError();
   // debounce event
-  InputMonitor.getInstance().addEvent(pvError, ERROR_EVENT_TYPE);
+  EventDebouncer.getInstance().addEvent(pvError, ERROR_EVENT_TYPE);
 }
 
 export { getOnURL, isErrorCollectedByNoibu, saveErrorToPagevisit };