noibu-react-native 0.0.9 → 0.1.2

package/dist/monitors/requestMonitor.js

@@ -1,78 +1,16 @@
 import 'react-native/Libraries/Network/fetch';
-import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError/pageVisitEventError.js';
-import { PageVisitEventHTTP, isHttpCodeFailure } from '../pageVisit/pageVisitEventHTTP/pageVisitEventHTTP.js';
+import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
+import { PageVisitEventHTTP, isHttpCodeFailure } from '../pageVisit/pageVisitEventHTTP.js';
 import { propWriteableOrMadeWriteable, replace } from '../utils/object.js';
-import 'react-native-device-info';
-import { PV_SEQ_ATT_NAME, XML_HTTP_REQUEST_ERROR_TYPE, GQL_ERROR_TYPE, SEVERITY, RESPONSE_ERROR_TYPE, HTTP_METHOD_ATT_NAME, HTTP_RESP_CODE_ATT_NAME, URL_ATT_NAME, HTTP_RESP_TIME_ATT_NAME, HTTP_RESP_LENGTH_ATT_NAME, FETCH_EXCEPTION_ERROR_TYPE } from '../constants.js';
-import { addSafeEventListener } from '../utils/eventlistener.js';
-import { HTTPDataBundler } from './httpDataBundler.js';
+import { SEVERITY, PV_SEQ_ATT_NAME, RESPONSE_ERROR_TYPE, GQL_ERROR_TYPE, HTTP_METHOD_ATT_NAME, HTTP_RESP_CODE_ATT_NAME, URL_ATT_NAME, HTTP_RESP_TIME_ATT_NAME, HTTP_RESP_LENGTH_ATT_NAME, FETCH_EXCEPTION_ERROR_TYPE } from '../constants.js';
 import ClientConfig from '../api/clientConfig.js';
+import { HTTPDataBundler } from './httpDataBundler.js';
 import GqlErrorValidator from './gqlErrorValidator.js';
+import { noibuLog } from '../utils/log.js';
 
 /** @module RequestMonitor */
 // todo no idea why this works but it fixes fetch replacement
 
-/**
- * Takes an XHR object, method, url, response time, and payload, and returns the parameters to pass
- * the PageVisitEventHTTP constructor.
- * @param {object} xhrObj
- * @param {string} method
- * @param {string} url
- * @param {number} respTime
- * @param {*} rawPayload
- * @returns HTTP event and data
- */
-function _buildHttpEventDataObjectsForXHR(
-  xhrObj,
-  method,
-  url,
-  respTime,
-  rawPayload = null,
-) {
-  const httpEvent = {
-    [HTTP_METHOD_ATT_NAME]: method,
-    [HTTP_RESP_CODE_ATT_NAME]: xhrObj.status,
-    [URL_ATT_NAME]: url,
-    [HTTP_RESP_TIME_ATT_NAME]: respTime,
-  };
-  let httpData = null;
-
-  if (HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
-    const responseHeaders = HTTPDataBundler.headersMapFromString(
-      xhrObj.getAllResponseHeaders(),
-    );
-    // add response payload length, if any
-    const contentLength =
-      HTTPDataBundler.getInstance().contentLength(responseHeaders);
-    if (contentLength > 0) {
-      httpEvent[HTTP_RESP_LENGTH_ATT_NAME] = contentLength;
-    }
-
-    let responseBody = '';
-    if (HTTPDataBundler.getInstance().shouldCollectPayloadForURL(url)) {
-      // Set descriptive body if content is wrong type or too long.
-      const droppedResponseText =
-        HTTPDataBundler.getInstance().dropPayloadIfNecessaryFromHeaders(
-          responseHeaders,
-        );
-
-      responseBody =
-        droppedResponseText ||
-        HTTPDataBundler.responseStringFromXHRResponseType(xhrObj);
-    }
-
-    httpData = HTTPDataBundler.getInstance().bundleHTTPData(
-      url,
-      xhrObj.noibuRequestHeaders,
-      rawPayload,
-      responseHeaders,
-      responseBody,
-      method,
-    );
-  }
-  return [httpEvent, httpData];
-}
-
 /**
  * Called in the fetch() wrapper function, this specifically gets called after the promises which
  * return the request and response body complete.
@@ -83,6 +21,7 @@ function _buildHttpEventDataObjectsForXHR(
  * [0] is the response body, [1] is an optional response body.
  * @param {string} url the URL of the request
  * @param {string} method the method used in the fetch call
+ * @param {boolean} shouldCollectPayload
  * @returns the return from the bundleHTTPData() call
  */
 function _handleFetchOnPromiseCompletion(
@@ -92,7 +31,9 @@ function _handleFetchOnPromiseCompletion(
   bodyStrings,
   url,
   method,
+  shouldCollectPayload,
 ) {
+  noibuLog('_handleFetchOnPromiseCompletion', method, url);
   let reqBody; //
   let reqHeaders = new Map();
   let respHeaders = new Map();
@@ -147,6 +88,7 @@ function _handleFetchOnPromiseCompletion(
     respHeaders,
     bodyStrings[0],
     method,
+    shouldCollectPayload,
   );
 }
 
@@ -171,6 +113,7 @@ async function _buildHttpEventDataObjectsForFetch(
   respTime,
   requestTextPromise,
 ) {
+  noibuLog('_buildHttpEventDataObjectsForFetch started', method, url);
   const httpEvent = {
     [HTTP_METHOD_ATT_NAME]: method,
     [HTTP_RESP_CODE_ATT_NAME]: response.status,
@@ -192,15 +135,24 @@ async function _buildHttpEventDataObjectsForFetch(
     }
 
     let responseText = '';
-    if (
-      HTTPDataBundler.getInstance().shouldCollectPayloadForURL(url) &&
-      response instanceof Response
-    ) {
+    const shouldCollectPayload =
+      HTTPDataBundler.getInstance().shouldCollectPayloadForURL(url);
+    if (shouldCollectPayload && response instanceof Response) {
+      noibuLog('_buildHttpEventDataObjectsForFetch collecting response');
       const droppedResponseText =
         HTTPDataBundler.getInstance().dropPayloadIfNecessaryFromHeaders(
           response.headers,
         );
       responseText = droppedResponseText || response.clone().text();
+    } else {
+      noibuLog(
+        '_buildHttpEventDataObjectsForFetch not collecting payload, because of',
+        {
+          shouldCollectPayloadForURL:
+            HTTPDataBundler.getInstance().shouldCollectPayloadForURL(url),
+          instanceOfCheck: response instanceof Response,
+        },
+      );
     }
     const responseTextPromise = Promise.resolve(responseText);
 
@@ -222,224 +174,19 @@ async function _buildHttpEventDataObjectsForFetch(
           data,
           url,
           method,
+          shouldCollectPayload,
         ),
       )
       .then(httpDataReturn => {
         httpData = httpDataReturn;
       });
   }
+  noibuLog('_buildHttpEventDataObjectsForFetch ended');
   // This return will await the _handleFetchOnPromiseCompletion() call if necessary,
   // but won't if not. (See if above).
   return [httpEvent, httpData];
 }
 
-/**
- * Wraps the send prototype of the xmlhttp object
- * @param  {object} proto window.XMLHTTPRequest's prototype
- */
-function wrapXMLHTTPSend(proto) {
-  replace(
-    proto,
-    'send',
-    originalFunction =>
-      // We set nbuWrapper to the handler function so if this returns an error
-      // the trace message will start with nbuWrapper which would allow us to
-      // detect that this is a wrapped function and not a NoibuJS error
-      function nbuXMLHTTPSendWrapper(data) {
-        // We wrap all of our logic in a try block to guarantee that we will complete the original
-        // implementation if we throw an error in our logic.
-        try {
-          let method;
-          if (this.noibuHttpMethod) {
-            method = this.noibuHttpMethod;
-          } else {
-            // This is very hacky but we do not really have an option as
-            // we do not have access to either the url nor the method when
-            // overiding the send method
-            method = data ? 'POST' : 'GET';
-          }
-          // not using safePerformanceNow as there is a 70% hit with using it.
-          // We don't want every request to get impacted by this.
-          const rCreatedAt = new Date();
-          // on loadend we catch the event and
-          // make sure it was correct
-          addSafeEventListener(this, 'loadend', async () => {
-            const rEndedAt = new Date();
-            const respTime = Math.abs(rEndedAt - rCreatedAt);
-            // Prefer the URL from the open() call if it is defined.
-            const url = this.noibuHttpUrl || this.responseURL;
-            const gqlError = await GqlErrorValidator.fromXhr(url, this);
-
-            const [httpEvent, httpData] = _buildHttpEventDataObjectsForXHR(
-              this,
-              method,
-              url,
-              respTime,
-              gqlError,
-              data,
-            );
-
-            // Save HTTP Info
-            let pageVisitEventHTTP = new PageVisitEventHTTP(
-              httpEvent,
-              httpData,
-            );
-            pageVisitEventHTTP.saveHTTPEvent();
-
-            const seq =
-              pageVisitEventHTTP.httpData &&
-              pageVisitEventHTTP.httpData[PV_SEQ_ATT_NAME];
-            if (isHttpCodeFailure(this.status)) {
-              saveErrorToPagevisit(XML_HTTP_REQUEST_ERROR_TYPE, this, seq);
-            }
-
-            if (gqlError) {
-              gqlError.forEach(error =>
-                saveErrorToPagevisit(GQL_ERROR_TYPE, error, seq),
-              );
-            }
-
-            // helping gc
-            pageVisitEventHTTP = null;
-          }); // End of loadend callback, return to synchronous code below
-        } catch (e) {
-          ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-            `Error in XHR.send() wrapper: ${e}`,
-            false,
-            SEVERITY.error,
-          );
-        }
-        return originalFunction.call(this, data);
-      },
-  );
-}
-
-/**
- * Wraps the open prototype of the xmlhttp object
- * @param  {object} proto window.XMLHTTPRequest's prototype
- * @param {boolean} shouldHandleLoadend Whether the wrapped XHR.open() function should be
- * responsible for listening to 'loadend' events. (Used in the case where the XHR.send()
- * function on the XHR prototype cannot be modified.)
- */
-function wrapXMLHTTPOpen(proto, shouldHandleLoadend) {
-  replace(
-    proto,
-    'open',
-    originalFunction =>
-      // We set nbuWrapper to the handler function so if this returns an error
-      // the trace message will start with nbuWrapper which would allow us to
-      // detect that this is a wrapped function and not a NoibuJS error
-      function nbuXMLHTTPOpenWrapper(
-        method,
-        url,
-        async = true,
-        user = null,
-        password = null,
-      ) {
-        // We wrap all of our logic in a try block to guarantee that we will complete the original
-        // implementation if we throw an error in our logic.
-        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.
-          try {
-            this.noibuHttpMethod = method;
-            this.noibuHttpUrl = url;
-          } catch (error) {
-            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-              `Unable to set custom properties on XHR object: ${error}`,
-              false,
-              SEVERITY.warn,
-            );
-          }
-
-          if (shouldHandleLoadend) {
-            // on loadend we catch the event and
-            // make sure it was correct
-            const rCreatedAt = new Date();
-            addSafeEventListener(this, 'loadend', async () => {
-              const rEndedAt = new Date();
-              const respTime = Math.abs(rEndedAt - rCreatedAt);
-              const gqlError = await GqlErrorValidator.fromXhr(url, this);
-
-              const [httpEvent, httpData] = _buildHttpEventDataObjectsForXHR(
-                this,
-                method,
-                url,
-                respTime,
-                gqlError,
-              );
-
-              let pageVisitEventHTTP = new PageVisitEventHTTP(
-                httpEvent,
-                httpData,
-              );
-
-              // Save HTTP Info
-              pageVisitEventHTTP.saveHTTPEvent();
-              const seq =
-                pageVisitEventHTTP.httpData &&
-                pageVisitEventHTTP.httpData[PV_SEQ_ATT_NAME];
-              if (isHttpCodeFailure(this.status)) {
-                saveErrorToPagevisit(XML_HTTP_REQUEST_ERROR_TYPE, this, seq);
-              }
-
-              if (gqlError) {
-                gqlError.forEach(error =>
-                  saveErrorToPagevisit(GQL_ERROR_TYPE, error, seq),
-                );
-              }
-
-              // helping gc
-              pageVisitEventHTTP = null;
-            }); // End of loadend callback, return to synchronous code below
-          }
-        } catch (e) {
-          ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-            `Error in XHR.open() wrapper: ${e}`,
-            false,
-            SEVERITY.error,
-          );
-        }
-        return originalFunction.call(this, method, url, async, user, password);
-      },
-  );
-}
-
-/**
- * Replaces the native XMLHTTPRequest.setHeader() function. We use this to build an array of
- * request headers as these are not stored by the XMLHTTPRequest object.
- * @param {object} proto window.XMLHTTPRequest's prototype
- */
-function wrapXMLHTTPSetRequestHeader(proto) {
-  replace(
-    proto,
-    'setRequestHeader',
-    originalFunction =>
-      function nbuXMLHTTPSetRequestHeaderWrapper(header, value) {
-        // We wrap all of our logic in a try block to guarantee that we will complete the original
-        // implementation if we throw an error in our logic.
-        try {
-          if (
-            !this.noibuRequestHeaders ||
-            !(this.noibuRequestHeaders instanceof Map)
-          ) {
-            this.noibuRequestHeaders = new Map();
-          }
-          // Ensure it's a string. This also converts null to "null"
-          const stringValue = typeof value === 'string' ? value : String(value);
-          this.noibuRequestHeaders.set(header.toLowerCase(), stringValue);
-        } catch (error) {
-          ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-            `Error in XHR.setRequestHeader() wrapper: ${error}`,
-            false,
-            SEVERITY.error,
-          );
-        }
-        return originalFunction.call(this, header, value);
-      },
-  );
-}
-
 /**
  * Handles fetch failure
  * @param  {} err
@@ -473,12 +220,12 @@ function handleFetchFailure(err, url) {
  */
 function setupGlobalFetchWrapper() {
   const proto = global;
-
   // Ensure we're able to replace the fetch() function
   if (!propWriteableOrMadeWriteable(proto, 'fetch')) {
+    noibuLog('setupGlobalFetchWrapper fetch is not writable');
     return;
   }
-
+  noibuLog('setupGlobalFetchWrapper replacing fetch');
   replace(
     proto,
     'fetch',
@@ -500,6 +247,7 @@ function setupGlobalFetchWrapper() {
         // We wrap everything in try/catch to ensure the original function is called even if we throw
         // an unexpected error.
         try {
+          noibuLog('nbuGlobalFetchWrapper start call', { resource });
           // There is no valid reason for fetch() to be called without a resource but we
           // see it on a bunch of websites. It seems to work the same as empty string
           if (!resource) {
@@ -524,11 +272,24 @@ function setupGlobalFetchWrapper() {
               resource.clone &&
               resource.text
             ) {
+              noibuLog('nbuGlobalFetchWrapper collecting request object');
               // We clone the request object, as its body can only be read once per instance.
               // It's important that we do this before the original function is called, as it
               // cannot be cloned afterwards.
               request = resource.clone();
               requestTextPromise = request.text();
+            } else {
+              noibuLog(
+                'nbuGlobalFetchWrapper not collecting request object, because one of these is false',
+                {
+                  shouldCollectPayloadForURL:
+                    HTTPDataBundler.getInstance().shouldCollectPayloadForURL(
+                      url,
+                    ),
+                  clone: !!resource.clone,
+                  text: !!resource.text,
+                },
+              );
             }
           }
         } catch (e) {
@@ -541,6 +302,7 @@ function setupGlobalFetchWrapper() {
 
         // Break out of the try wrapper momentarily to make the original call
 
+        noibuLog('nbuGlobalFetchWrapper call original');
         // Can't put this inside finally as const needs to be defined outside it.
         const promiseFromOriginalFetch = originalFunction.call(
           this,
@@ -552,6 +314,7 @@ function setupGlobalFetchWrapper() {
         const rCreatedAt = new Date();
         promiseFromOriginalFetch
           .then(async response => {
+            noibuLog('nbuGlobalFetchWrapper got response');
             // We wrap the callback in try in order to only catch real fetch failures in the promise's
             // .catch() call
             try {
@@ -624,41 +387,15 @@ function setupGlobalFetchWrapper() {
       },
   );
 }
-
-/**
- * Setting up the wrapper around send functions to try and
- * catch http errors
- */
-function setupGlobalXMLHttpWrapper() {
-  const XMLHttp = window.XMLHttpRequest;
-  // The event target needs to have a prototype and have the open function
-  const proto = XMLHttp && XMLHttp.prototype;
-
-  const canWriteOpen = propWriteableOrMadeWriteable(proto, 'open');
-  const canWriteSend = propWriteableOrMadeWriteable(proto, 'send');
-  const canWriteSetHeader = propWriteableOrMadeWriteable(
-    proto,
-    'setRequestHeader',
-  );
-
-  if (canWriteOpen) {
-    // If we can't wrap the XHR.send() function, we need the wrapped .open() function to
-    // set the listener on 'loadend' events.
-    wrapXMLHTTPOpen(proto, !canWriteSend);
-  }
-  if (canWriteSend) {
-    wrapXMLHTTPSend(proto);
-  }
-  if (canWriteSetHeader) {
-    wrapXMLHTTPSetRequestHeader(proto);
-  }
-}
 /**
  * Monitors all requests
  */
 function monitorRequests() {
-  setupGlobalXMLHttpWrapper();
+  noibuLog('monitorRequests started');
+  /** todo: disabling xmlhttp since it seems to duplicate fetch wrapper, but lacks response body capture */
+  // setupGlobalXMLHttpWrapper();
   setupGlobalFetchWrapper();
+  noibuLog('monitorRequests ended');
 }
 
 export { handleFetchFailure, monitorRequests };

package/dist/pageVisit/{pageVisitEventError/pageVisitEventError.js → pageVisitEventError.js}

@@ -1,12 +1,22 @@
-import { isValidURL, asString, getMaxSubstringAllowed, getJSStack, stringifyJSON } from '../../utils/function.js';
-import { EVENT_ERROR_TYPE, URL_ATT_NAME, 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 blacklisedDomains from './blacklistedDomains.js';
-import ClientConfig from '../../api/clientConfig.js';
-import { InputMonitor } from '../../monitors/inputMonitor.js';
-import StoredMetrics from '../../api/storedMetrics.js';
+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';
 
 /** @module PageVisitEventError */
 
+/**
+ * gets the onURL of a string, defaulting to the location of the webpage
+ */
+function getOnURL(realOnURL) {
+  if (realOnURL && realOnURL.trim() !== '' && realOnURL !== 'undefined') {
+    return asString(getMaxSubstringAllowed(realOnURL));
+  }
+
+  return ClientConfig.getInstance().globalUrl;
+}
+
 /**
  * getPVErrorFromResponse will create the error information from an
  * http response error type.
@@ -25,21 +35,10 @@ function getPVErrorFromResponse(errPayload, httpDataSeqNum) {
   return errorObject;
 }
 
-/**
- * gets the onURL of a string, defaulting to the location of the webpage
- */
-function getOnURL(realOnURL) {
-  if (realOnURL && realOnURL.trim() !== '' && realOnURL !== 'undefined') {
-    return asString(getMaxSubstringAllowed(realOnURL));
-  }
-
-  return ClientConfig.getInstance().globalUrl;
-}
-
 /**
  * getPVErrorFromGqlError will create the error information from an
  * GraphQL error payload.
- * @param  {} errPayload
+ * @param payload
  * @param  {} httpDataSeqNum
  */
 function getPVErrorFromGqlError(payload, httpDataSeqNum) {
@@ -210,7 +209,7 @@ function createPageVisitEventError(type, errPayload, httpDataSeqNum) {
  * determines if an error is a collect error
  * @param  {} pvError
  */
-function isCollectError(pvError) {
+function isErrorCollectedByNoibu(pvError) {
   // checking if this error originated from the Noibu script
   if (pvError[TYPE_ATT_NAME] === JS_EVENT_TYPE) {
     if (pvError[JS_ERROR_ATT_NAME]) {
@@ -222,6 +221,7 @@ function isCollectError(pvError) {
 
         if (
           lowerCapFile.includes('noibu') &&
+          !lowerCapFile.includes('examplenoibureactnativeapp') &&
           !lowerCapMethod.includes('nbuwrapper')
         ) {
           // if the first file in the stack is Noibu then we do not
@@ -302,12 +302,12 @@ function saveErrorToPagevisit(type, payload, httpDataSeqNum) {
     const urlOb = new URL(currErrURL);
 
     // if the domain is blacklisted we drop the error
-    if (urlOb.hostname in blacklisedDomains) {
+    if (urlOb.hostname in BLOCKLISTED_DOMAINS) {
       return;
     }
   }
 
-  if (isCollectError(pvError)) {
+  if (isErrorCollectedByNoibu(pvError)) {
     return;
   }
 
@@ -317,4 +317,4 @@ function saveErrorToPagevisit(type, payload, httpDataSeqNum) {
   InputMonitor.getInstance().addEvent(pvError, ERROR_EVENT_TYPE);
 }
 
-export { getOnURL, isCollectError, saveErrorToPagevisit };
+export { getOnURL, isErrorCollectedByNoibu, saveErrorToPagevisit };

package/dist/pageVisit/{pageVisitEventHTTP/pageVisitEventHTTP.js → pageVisitEventHTTP.js}

@@ -1,10 +1,11 @@
-import { getMaxSubstringAllowed, asString } from '../../utils/function.js';
-import { timestampWrapper } from '../../utils/date.js';
-import { InputMonitor } from '../../monitors/inputMonitor.js';
-import { HTTP_METHOD_ATT_NAME, MAX_HTTP_DATA_EVENT_COUNT, PV_SEQ_ATT_NAME, HTTP_DATA_METROPLEX_TYPE, HTTP_EVENT_TYPE, PAGE_VISIT_HTTP_DATA_ATT_NAME } from '../../constants.js';
-import { PageVisit } from '../pageVisit.js';
-import StoredMetrics from '../../api/storedMetrics.js';
-import MetroplexSocket from '../../api/metroplexSocket.js';
+import { getMaxSubstringAllowed, asString } from '../utils/function.js';
+import { timestampWrapper } from '../utils/date.js';
+import { InputMonitor } from '../monitors/inputMonitor.js';
+import { HTTP_METHOD_ATT_NAME, MAX_HTTP_DATA_EVENT_COUNT, PV_SEQ_ATT_NAME, HTTP_DATA_METROPLEX_TYPE, HTTP_EVENT_TYPE, PAGE_VISIT_HTTP_DATA_ATT_NAME } from '../constants.js';
+import { PageVisit } from './pageVisit.js';
+import StoredMetrics from '../api/storedMetrics.js';
+import MetroplexSocket from '../api/metroplexSocket.js';
+import { noibuLog } from '../utils/log.js';
 
 /** @module PageVisitEventHTTP */
 
@@ -49,12 +50,14 @@ class PageVisitEventHTTP {
 
   /** Saves the HTTP event to the pageVisit Queue */
   saveHTTPEvent() {
+    noibuLog('saveHTTPEvent');
     // we do not store http events that have empty urls
     if (
       !this.httpEvent ||
       !this.httpEvent.url ||
       this.httpEvent.url.trim() === ''
     ) {
+      noibuLog('saveHTTPEvent dropped due to empty url');
       return;
     }
     // we register an http event
@@ -62,6 +65,7 @@ class PageVisitEventHTTP {
 
     // send http data down to metroplex
     if (this.httpData) {
+      noibuLog('saveHTTPEvent got httpData, working');
       // 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
@@ -79,6 +83,9 @@ class PageVisitEventHTTP {
           metroplexMsg,
         );
       } else {
+        noibuLog(
+          'saveHTTPEvent have collected more than the max number of http requests for this page visit, so increment the over request limit count',
+        );
         // have collected more than the max number of http requests for this
         // page visit, so increment the over request limit count
         StoredMetrics.getInstance().addHttpDataOverLimit();
@@ -86,6 +93,7 @@ class PageVisitEventHTTP {
     }
     // if this was an error, send immediately so we don't lose it
     if (isHttpCodeFailure(this.httpEvent.code)) {
+      noibuLog('saveHTTPEvent is an error, sending immediately');
       PageVisit.getInstance().addPageVisitEvent(
         {
           event: this.httpEvent,

package/dist/pageVisit/{userStep/userStep.js → userStep.js}

@@ -1,5 +1,5 @@
-import { asString } from '../../utils/function.js';
-import { CSS_CLASS_ATT_NAME } from '../../constants.js';
+import { asString } from '../utils/function.js';
+import { CSS_CLASS_ATT_NAME } from '../constants.js';
 
 /** @module UserStep */
 /**

package/dist/react/ErrorBoundary.js

@@ -79,7 +79,7 @@ class ErrorBoundary extends React.Component {
                 element = fallback({
                     error,
                     componentStack,
-                    resetError: this.resetErrorBoundary,
+                    resetError: this.resetErrorBoundary.bind(this),
                     eventId,
                 });
             }

package/dist/types/globals.d.ts

@@ -14,19 +14,29 @@ declare global {
     const MAX_METROPLEX_RECONNECTION_NUMBER: number;
     const METROPLEX_CONSECUTIVE_CONNECTION_DELAY: number;
     const SCRIPT_ID: string;
+    const ENABLE_LOGGING: string;
     type Window = {
         noibuJSLoaded?: boolean;
     };
+    type PromiseRejectionTrackerOptions = Partial<{
+        allRejections: boolean;
+        whitelist: (typeof Error)[];
+        onUnhandled: (id: number, reason: any) => void;
+        onHandled: (id: number, reason: any) => void;
+    }>;
     type global = {
         window: Window;
         console: Console;
         noibuJSLoaded?: boolean;
         ErrorUtils: any;
         HermesInternal: null | {
-            enablePromiseRejectionTracker?: any;
-            setPromiseRejectionTrackingHook?: any;
+            enablePromiseRejectionTracker?: (options: PromiseRejectionTrackerOptions) => void;
+            setPromiseRejectionTrackingHook?: (enable: (options: PromiseRejectionTrackerOptions) => void) => void;
         };
     };
+    interface PromiseConstructor {
+        _m: <T>(promise: Promise<T>, error: any) => void;
+    }
     const global: global;
     const globalThis: global;
     const window: Window & global;