noibu-react-native 0.0.1 → 0.0.2

package/dist/monitors/errorMonitor.js

@@ -1,295 +1,142 @@
 import { replace } from '../utils/object.js';
-import 'stacktrace-parser';
-import 'react-native-device-info';
-import { ERROR_EVENT_ERROR_TYPE, EVENT_TARGETS, CONSOLE_FUNCTION_OVERRIDES, WRAPPED_EXCEPTION_ERROR_TYPE, ERROR_LOG_EVENT_ERROR_TYPE } from '../constants.js';
+import { isStackTrace } from '../utils/function.js';
+import { ERROR_EVENT_ERROR_TYPE, CONSOLE_FUNCTION_OVERRIDES, ERROR_LOG_EVENT_ERROR_TYPE } from '../constants.js';
 import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError/pageVisitEventError.js';
-import 'react-native-uuid';
 
+/* eslint-disable @typescript-eslint/ban-types,prefer-arrow-callback */
 /** @module ErrorMonitor */
-
-/**
- * will make sure that we ignore the next error caught by the error event listener
- * ignoreError is used to not store errors that were generated by noibu wrapped
- * code twice (once by wrapped code, once by error event listener).
- */
-function ignoreNextError() {
-
-  // this works because setTimeout without a delay fires
-  // as the immidiate next event in the event loop. Which should
-  // be right after the error that we throw before callign this error
-  setTimeout(() => {
-  });
-}
-
 /**
- * wraps a provided function into a function that try and catches
- * the original function, doing so allows us to catch errors
- * functionToWrap: function to be wrapped
- * @param  {} functionToWrap
+ * transform a log into an error since React hides component errors
+ * tps://reactjs.org/docs/error-boundaries.html
+ * @param  {Error|any} errorLog
+ * @returns {boolean} true on success
  */
-function wrap(functionToWrap) {
-  if (typeof functionToWrap !== 'function') {
-    return functionToWrap;
-  }
-
-  try {
-    // the function was wrapped already
-    if (functionToWrap.__noibu__) {
-      return functionToWrap;
-    }
-
-    // trying to wrap a function that was already wrapped in the past,
-    // return the wrapped value
-    if (functionToWrap.__noibu_wrapped__) {
-      return functionToWrap.__noibu_wrapped__;
-    }
-  } catch (err) {
-    // silently failling
-    return functionToWrap;
-  }
-  /**
-   * wrapper for most prototypes we know can generate errors
-   * @param  {} ...args
-   */
-  const nbuWrapper = function (...args) {
-    // Trying to call the function in a wrapped try and catch
-    // this will generate an error in the console if there is one.
-    try {
-      // Recursively wrap arguments in case that some are
-      // functions
-      const wrappedArguments = Array.prototype.slice
-        .call(args)
-        .map(arg => wrap(arg));
-
-      // checking if the function is served through the handleEvent property
-      // for compatibility reasons
-      if (functionToWrap.handleEvent) {
-        return functionToWrap.handleEvent.apply(this, wrappedArguments);
-      }
-      return functionToWrap.apply(this, wrappedArguments);
-      // user land
-    } catch (exception) {
-      // we need to ignore this error during the onerror otherwise
-      // we catch it 2x
-      saveErrorToPagevisit(WRAPPED_EXCEPTION_ERROR_TYPE, {
-        error: exception,
-      });
-      ignoreNextError();
-      throw exception;
+function processErrorLog(errorLog) {
+    // handle empty arguments
+    if (!errorLog) {
+        return false;
     }
-  };
-
-  try {
-    // eslint-disable-next-line no-restricted-syntax
-    for (const property in functionToWrap) {
-      if (Object.prototype.hasOwnProperty.call(functionToWrap, property)) {
-        nbuWrapper[property] = functionToWrap[property];
-      }
+    const { message, stack } = errorLog;
+    // for now, we only process error logs if they are a way to describe an error
+    if (!stack || !message) {
+        return false;
     }
-  } catch (err) {
-    // silently failling
-  }
-
-  nbuWrapper.prototype = functionToWrap.prototype || {};
-
-  Object.defineProperty(functionToWrap, '__noibu_wrapped__', {
-    enumerable: false,
-    value: nbuWrapper,
-  });
-
-  // Signal that this function has been wrapped/filled already
-  // for both debugging and to prevent it to being wrapped/filled twice
-  Object.defineProperties(nbuWrapper, {
-    __noibu__: {
-      enumerable: false,
-      value: true,
-    },
-    __noibu_original__: {
-      enumerable: false,
-      value: functionToWrap,
-    },
-  });
-
-  // Restore original function name (not all browsers allow that)
-  try {
-    const descriptor = Object.getOwnPropertyDescriptor(nbuWrapper, 'name');
-    if (descriptor.configurable) {
-      Object.defineProperty(nbuWrapper, 'name', {
-        // eslint-disable-next-line require-jsdoc
-        get() {
-          return functionToWrap.name;
-        },
-      });
-    }
-  } catch (err) {
-    return functionToWrap;
-  }
-
-  return nbuWrapper;
+    saveErrorToPagevisit(ERROR_LOG_EVENT_ERROR_TYPE, { message, stack });
+    return true;
 }
-
 /**
- * transform a log into an error since React hides component errors
- * tps://reactjs.org/docs/error-boundaries.html
- * @param  {} errorLog
+ * Constructs error objects based on console args.
+ * Relies on isStackTrace() to determine if arg is a stack trace, otherwise the arg must be a message.
+ *
+ * If there are multiple stack traces or the number of error messages is not equal to one,
+ * it maps the stack traces to objects with their respective first lines as messages.
+ * Otherwise, if there is exactly one stack trace and one error message,
+ * it constructs an array with a single object containing the first stack trace and the first error message.
+ * @param {Array<string>} args
  */
-function processErrorLog(errorLog) {
-  // handle empty arguments
-  if (!errorLog) {
-    return;
-  }
-  const { message, stack } = errorLog;
-  // for now we only process error logs if they are a way to describe an error
-  if (!stack || !message) {
-    return;
-  }
-
-  saveErrorToPagevisit(ERROR_LOG_EVENT_ERROR_TYPE, { message, stack });
+function constructErrors(args) {
+    if (args.length === 0) {
+        return [];
+    }
+    if (args.length === 2) {
+        if (isStackTrace(args[0])) {
+            return [{ stack: args[0], message: args[1] }];
+        }
+        if (isStackTrace(args[1])) {
+            return [{ stack: args[1], message: args[0] }];
+        }
+        return [];
+    }
+    const stacks = [];
+    const messages = [];
+    args.forEach(sm => {
+        if (isStackTrace(sm)) {
+            stacks.push(sm);
+            const lines = sm.split('\n');
+            if (isStackTrace(lines[0])) {
+                messages.push('_');
+            }
+            else {
+                // we can use 1st line of stack trace as a message
+                messages.push(lines[0]);
+            }
+        }
+    });
+    return stacks.map((stack, i) => ({ stack, message: messages[i] }));
 }
-
 /** iterates arguments to try to extract errors from them
- * @param  {} argsFromErrorLog
+ * @param  {Array<string | Error>} argsFromErrorLog
  */
 function processErrorLogArguments(argsFromErrorLog) {
-  // we may receive multiple arguments
-  argsFromErrorLog.forEach(arg => {
-    // ensure arg exists before attempting processing
-    if (!arg) {
-      return;
-    }
-    // if we pass an array of elements in the console, we want to go through that
-    // away and make sure we are extracting the error object. We dont do nested arrays.
-    if (Array.isArray(arg)) {
-      arg.forEach(nestedArg => {
-        processErrorLog(nestedArg);
-      });
-      return;
-    }
-    processErrorLog(arg);
-  });
+    // tracks if arguments were processed at least once successfully, and if not, tries to reconstruct an Error
+    const collectedArgs = [];
+    // we may receive multiple arguments
+    argsFromErrorLog.forEach(arg => {
+        // ensure arg exists before attempting processing
+        if (!arg) {
+            return;
+        }
+        // if we pass an array of elements in the console, we want to go through that
+        // away and make sure we are extracting the error object. We don't do nested arrays.
+        if (Array.isArray(arg)) {
+            collectedArgs.push(...arg);
+            return;
+        }
+        collectedArgs.push(arg);
+    });
+    const argsToBeReconstructedIntoErrors = collectedArgs.filter(arg => !processErrorLog(arg));
+    // if previous process calls return nothing,
+    // try to reconstruct error from the args
+    constructErrors(argsToBeReconstructedIntoErrors).forEach(processErrorLog);
 }
-
 /**
  * wraps and replaces the addEventListener property
  * of event targets to try and catch errors
  * eventTargetString: event target name
  */
 function configureEventListeners() {
-  EVENT_TARGETS.forEach(eventTargetString => {
-    const eventTarget = window[eventTargetString];
-    // The event target needs to have a prototype and have the
-    // addEventListener function
-    const proto = eventTarget && eventTarget.prototype;
-    if (
-      !proto ||
-      !proto.hasOwnProperty ||
-      // eslint-disable-next-line no-prototype-builtins
-      !proto.hasOwnProperty('addEventListener')
-    ) {
-      return;
-    }
-    replace(
-      proto,
-      'addEventListener',
-      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 nbuWrapper(eventName, handler, capture) {
-          // testPassive is done by passing a null handler, so we code
-          //  against that
-          if (!handler) {
-            return originalFunction.call(this, eventName, handler, capture);
-          }
-          let wrappedHandler;
-          // Checking if handleEvent is explicitely
-          // passed for compatibility reason
-          if (handler.handleEvent) {
-            const wrappedHandleEvent = wrap(handler.handleEvent.bind(handler));
-            // in some case the handler is an object that contains much more than just the
-            // the single handle event property, in such cases we need to make sure we are not
-            // overwritting any other critical functionality by wrapping the event handler
-            wrappedHandler = handler;
-            wrappedHandler.handleEvent = wrappedHandleEvent;
-          } else {
-            wrappedHandler = wrap(handler);
-          }
-
-          return originalFunction.call(
-            this,
-            eventName,
-            wrappedHandler,
-            capture,
-          );
-        },
-    );
-
-    // replacing the removeEventListener function as well to wrap the listener
-    replace(
-      proto,
-      'removeEventListener',
-      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 nbuWrapper(eventName, handler, options) {
-          let callback = handler;
-          try {
-            callback = callback && (callback.__noibu_wrapped__ || callback);
-          } catch (e) {
-            // fail silently
-          }
-          return originalFunction.call(this, eventName, callback, options);
-        },
-    );
-  });
-
-  // we wrap all logging to catch any potential errors passed in logs
-  CONSOLE_FUNCTION_OVERRIDES.forEach(consoleFunction => {
-    if (!window.console || !window.console[consoleFunction]) {
-      return;
-    }
-    replace(
-      window.console,
-      consoleFunction,
-      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 nbuWrapper() {
-          // ignoring this linting error since we don't want
-          // potentially overide the actual functioning of console.error
-          // eslint-disable-next-line prefer-rest-params
-          originalFunction.call(window.console, ...arguments);
-          // converting the arguments to an array so that we do not nest argument objects
-          // eslint-disable-next-line prefer-rest-params
-          processErrorLogArguments(Array.from(arguments));
-        },
-    );
-  });
+    // we wrap all logging to catch any potential errors passed in logs
+    CONSOLE_FUNCTION_OVERRIDES.forEach(consoleFunction => {
+        if (!window.console || !window.console[consoleFunction]) {
+            return;
+        }
+        replace(window.console, consoleFunction, function (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
+            return function nbuWrapper() {
+                // ignoring this linting error since we don't want
+                // potentially overide the actual functioning of console.error
+                // eslint-disable-next-line prefer-rest-params
+                originalFunction.call(window.console, ...arguments);
+                // converting the arguments to an array so that we do not nest argument objects
+                // eslint-disable-next-line prefer-rest-params
+                processErrorLogArguments(Array.from(arguments));
+            };
+        });
+    });
 }
-
 /**
  * Monitors the errors happening on the window
  */
 function monitorErrors() {
-  // wrapping all listeners as soon as possible after we set the above listener
-  configureEventListeners();
-  global.ErrorUtils.setGlobalHandler((error, isFatal) => {
-    saveErrorToPagevisit(ERROR_EVENT_ERROR_TYPE, {
-      error,
-    });
-  }, true);
-  if (global.HermesInternal) {
-    global.HermesInternal.enablePromiseRejectionTracker({
-      allRejections: true,
-      onUnhandled: (id, rejection = {}) => {
+    // wrapping all listeners as soon as possible after we set the above listener
+    configureEventListeners();
+    global.ErrorUtils.setGlobalHandler((error) => {
         saveErrorToPagevisit(ERROR_EVENT_ERROR_TYPE, {
-          error: rejection,
+            error,
         });
-      },
-    });
-  }
+    }, true);
+    if (global.HermesInternal) {
+        global.HermesInternal.enablePromiseRejectionTracker({
+            allRejections: true,
+            onUnhandled: (id, rejection = {}) => {
+                saveErrorToPagevisit(ERROR_EVENT_ERROR_TYPE, {
+                    error: rejection,
+                });
+            },
+        });
+    }
 }
 
 export { monitorErrors, processErrorLogArguments };

package/dist/monitors/httpDataBundler.js

@@ -85,7 +85,10 @@ class HTTPDataBundler {
     ];
   }
 
-  /** gets the singleton instance */
+  /**
+   * gets the singleton instance
+   * @returns {HTTPDataBundler}
+   */
   static getInstance() {
     if (!this.instance) {
       this.instance = new HTTPDataBundler();
@@ -208,7 +211,7 @@ class HTTPDataBundler {
       return false;
     }
 
-    let requestHostname; // has to be declared outside of `try`
+    let requestHostname; // has to be declared outside `try`
 
     // Use URL constructor to extract hostname
     try {
@@ -251,11 +254,10 @@ class HTTPDataBundler {
    * Builds an HTTP Data bundle
    * @param  {} url
    * @param  {} requestHeaders is a map of request headers
-   * @param  {} requestPayload
+   * @param  {} rawRequestPayload
    * @param  {} responseHeaders is a map of response headers
    * @param  {} responsePayload
    * @param  {} method
-   * @param  {} isError Response code is an error
    */
   bundleHTTPData(
     url,
@@ -264,9 +266,8 @@ class HTTPDataBundler {
     responseHeaders,
     responsePayload,
     method,
-    isError,
   ) {
-    if (!this.isValidRequest(url, method, isError)) return null;
+    if (!this.isValidRequest(url, method)) return null;
 
     // stringify payload if correct type and not too large
     let requestPayload = '';
@@ -320,15 +321,13 @@ class HTTPDataBundler {
    * de-duping the requests
    * @param {string} url
    * @param {string} method
-   * @param  {} isError Response code is an error
    * @returns boolean indicating whether the validation passed
    */
-  isValidRequest(url, method, isError) {
+  isValidRequest(url, method) {
     if (!this.httpDataCollectionEnabled) return false;
     if (!method || typeof method !== 'string') {
       return false;
     }
-    if (!isError) return false;
     // TODO: Check below disabled for beta. NOI-4253
     // only bundle and send once per request/method/response code combination
     // const urlWithoutParams = url.split('?')[0];
@@ -408,7 +407,7 @@ class HTTPDataBundler {
    * @returns the restricted payload
    */
   restrictPayload(payload, url) {
-    // if no payload, too large, payload already dropped,
+    // if no payload, or 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;
@@ -611,7 +610,7 @@ ${HTTPDataBundler.getInstance().contentLength(headers)}`;
     if (typeof dirtyBody !== 'string') return null;
     if (dirtyBody.length < 1) return dirtyBody;
 
-    let cleanString = this.tryPaseObjectAndRemovePII(dirtyBody);
+    let cleanString = this.tryParseObjectAndRemovePII(dirtyBody);
     // Go through each of the PII matching patterns
     HTTP_PII_BLOCKING_PATTERNS.forEach(pattern => {
       // Replace all matches with the appropriate number of asterisks
@@ -630,7 +629,7 @@ ${HTTPDataBundler.getInstance().contentLength(headers)}`;
    * Returns original content if nothing was changes or error is thrown.
    * @param {String} content
    */
-  tryPaseObjectAndRemovePII(content) {
+  tryParseObjectAndRemovePII(content) {
     const first = content[0];
     const isParsable = first === '{' || first === '[';
     if (!isParsable) {

package/dist/monitors/inputMonitor.js

@@ -42,7 +42,10 @@ class InputMonitor {
     this._setupUnloadHandler();
   }
 
-  /** gets the instance of InputMonitor */
+  /**
+   * gets the instance of InputMonitor
+   * @returns {InputMonitor}
+   */
   static getInstance() {
     if (!this.instance) {
       this.instance = new InputMonitor();

package/dist/monitors/locationChangeMonitor.js

@@ -1,11 +1,9 @@
-import { getProperGlobalUrl } from '../utils/function.js';
-import { InputMonitor } from './inputMonitor.js';
-import { URL_ATT_NAME, LOCATION_EVENT_TYPE } from '../constants.js';
+import 'react-native-device-info';
+import 'react-native-localize';
+import 'react-native-uuid';
 
 /** @module LocationMonitor */
 
-let currentLocation = (window.location && window.location.href) || '';
-
 /**
  * will poll the url on a 1 second basis to see if it has changed
  * there is currently no alternative to getting an accurate url
@@ -13,17 +11,6 @@ let currentLocation = (window.location && window.location.href) || '';
  */
 function monitorLocation() {
   setInterval(() => {
-    if (currentLocation !== ((window.location && window.location.href) || '')) {
-      // updating the current url to be the new one
-      currentLocation = (window.location && window.location.href) || '';
-
-      const payload = {
-        [URL_ATT_NAME]: getProperGlobalUrl(),
-      };
-
-      // storing the location change in the page visit queue
-      InputMonitor.getInstance().addEvent(payload, LOCATION_EVENT_TYPE);
-    }
   }, 1000);
 }
 

package/dist/monitors/pageMonitor.js

@@ -6,7 +6,10 @@ import { addSafeEventListener } from '../utils/eventlistener.js';
 
 /** Monitors the page events which we capture and later process */
 class PageMonitor {
-  /** gets the singleton instance */
+  /**
+   * gets the singleton instance
+   * @returns {PageMonitor}
+   */
   static getInstance() {
     if (!this.instance) {
       this.instance = new PageMonitor();

package/dist/monitors/requestMonitor.js

@@ -2,12 +2,12 @@ import 'react-native/Libraries/Network/fetch';
 import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError/pageVisitEventError.js';
 import { PageVisitEventHTTP, isHttpCodeFailure } from '../pageVisit/pageVisitEventHTTP/pageVisitEventHTTP.js';
 import { propWriteableOrMadeWriteable, replace } from '../utils/object.js';
-import 'stacktrace-parser';
 import 'react-native-device-info';
+import 'react-native-localize';
 import { PV_SEQ_ATT_NAME, XML_HTTP_REQUEST_ERROR_TYPE, GQL_ERROR_TYPE, SEVERITY_ERROR, SEVERITY_WARN, 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 ClientConfig from '../api/clientConfig.js';
 import { addSafeEventListener } from '../utils/eventlistener.js';
 import { HTTPDataBundler } from './httpDataBundler.js';
-import ClientConfig from '../api/clientConfig.js';
 import GqlErrorValidator from './gqlErrorValidator.js';
 
 /** @module RequestMonitor */
@@ -20,7 +20,6 @@ import GqlErrorValidator from './gqlErrorValidator.js';
  * @param {string} method
  * @param {string} url
  * @param {number} respTime
- * @param {object} gqlError
  * @param {*} rawPayload
  * @returns HTTP event and data
  */
@@ -29,7 +28,6 @@ function _buildHttpEventDataObjectsForXHR(
   method,
   url,
   respTime,
-  gqlError,
   rawPayload = null,
 ) {
   const httpEvent = {
@@ -39,9 +37,8 @@ function _buildHttpEventDataObjectsForXHR(
     [HTTP_RESP_TIME_ATT_NAME]: respTime,
   };
   let httpData = null;
-  const isGqlError = gqlError != null;
-  const isError = isHttpCodeFailure(xhrObj.status) || isGqlError;
-  if (isError && HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
+
+  if (HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
     const responseHeaders = HTTPDataBundler.headersMapFromString(
       xhrObj.getAllResponseHeaders(),
     );
@@ -72,7 +69,6 @@ function _buildHttpEventDataObjectsForXHR(
       responseHeaders,
       responseBody,
       method,
-      isError,
     );
   }
   return [httpEvent, httpData];
@@ -88,7 +84,6 @@ 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} isError is an error
  * @returns the return from the bundleHTTPData() call
  */
 function _handleFetchOnPromiseCompletion(
@@ -98,7 +93,6 @@ function _handleFetchOnPromiseCompletion(
   bodyStrings,
   url,
   method,
-  isError,
 ) {
   let reqBody; //
   let reqHeaders = new Map();
@@ -154,7 +148,6 @@ function _handleFetchOnPromiseCompletion(
     respHeaders,
     bodyStrings[0],
     method,
-    isError,
   );
 }
 
@@ -167,7 +160,6 @@ function _handleFetchOnPromiseCompletion(
  * @param {object} options the options parameter from the original fetch() call
  * @param {number} respTime the time between the fetch() call and the the resolution of the
  * original implementation's return
- * @param {object} gqlError a GraphQL error object
  * @param {Promise<string>} requestTextPromise
  * @returns an array in the form [httpEvent, httpData]
  */
@@ -179,7 +171,6 @@ async function _buildHttpEventDataObjectsForFetch(
   options,
   respTime,
   requestTextPromise,
-  gqlError,
 ) {
   const httpEvent = {
     [HTTP_METHOD_ATT_NAME]: method,
@@ -189,10 +180,8 @@ async function _buildHttpEventDataObjectsForFetch(
   };
 
   let httpData = null;
-  const isGqlError = gqlError != null;
-  const isError = isHttpCodeFailure(response.status) || isGqlError;
   // Only get the bodies of the request and response on error and if the URL is one we care about.
-  if (isError && HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
+  if (HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
     // add response payload length, if any
     if (response && response.headers) {
       const contentLength = HTTPDataBundler.getInstance().contentLength(
@@ -206,7 +195,6 @@ async function _buildHttpEventDataObjectsForFetch(
     let responseText = '';
     if (
       HTTPDataBundler.getInstance().shouldCollectPayloadForURL(url) &&
-      !!response &&
       response instanceof Response
     ) {
       const droppedResponseText =
@@ -235,7 +223,6 @@ async function _buildHttpEventDataObjectsForFetch(
           data,
           url,
           method,
-          isError,
         ),
       )
       .then(httpDataReturn => {
@@ -591,7 +578,6 @@ function setupGlobalFetchWrapper() {
                   options,
                   respTime,
                   requestTextPromise,
-                  gqlError,
                 );
 
               let pageVisitEventHTTP = new PageVisitEventHTTP(