noibu-react-native 0.2.6 → 0.2.7

package/dist/pageVisit/pageVisitEventError.js

@@ -1,320 +1,210 @@
+import { __awaiter } from 'tslib';
 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 StoredMetrics from '../api/storedMetrics.js';
+import { SEVERITY } from '../constants.js';
+import ClientConfig from '../api/ClientConfig.js';
+import StoredMetrics from '../api/StoredMetrics.js';
 import { EventDebouncer } from './EventDebouncer.js';
-
-/** @module PageVisitEventError */
-
+import '../node_modules/@noibu/metroplex-ts-bindings/dist/index.js';
+import { PageVisitErrorSource } from '../node_modules/@noibu/metroplex-ts-bindings/dist/PageVisitErrorSource.js';
+import { EventType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/EventType.js';
+import { ErrorType } from '../node_modules/@noibu/metroplex-ts-bindings/dist/ErrorType.js';
+
+const BLOCKLISTED_DOMAINS = {
+    'input.noibu.com': true,
+    'input.staging.noibu.com': true,
+    'vf.noibu.com': true,
+    'vf.staging.noibu.com': true,
+    'cdn.noibu.com': true,
+};
+// All urls that NoibuJS may talk to
+const NOIBU_INPUT_URLS = [
+    'i.noibu',
+    'i.staging.noibu',
+    'input.staging.noibu',
+    'input.b.noibu',
+    'input.noibu',
+    'vf.staging.noibu',
+    'vf.noibu',
+];
 /**
  * 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;
+    if (typeof realOnURL === 'string' && !!realOnURL.trim() && realOnURL !== 'undefined') {
+        return asString(getMaxSubstringAllowed(realOnURL));
+    }
+    return ClientConfig.getInstance().globalUrl;
 }
-
 /**
  * getPVErrorFromResponse will create the error information from an
- * http response error type.
- * @param  {} errPayload
- * @param  {} httpDataSeqNum
- */
-function getPVErrorFromResponse(errPayload, httpDataSeqNum) {
-  const errorObject = {
-    [URL_ATT_NAME]: getOnURL(errPayload.url),
-    [TYPE_ATT_NAME]: HTTP_EVENT_TYPE,
-    [HTTP_CODE_ATT_NAME]: errPayload.status,
-  };
-  if (httpDataSeqNum || httpDataSeqNum === 0) {
-    errorObject[PV_SEQ_ATT_NAME] = httpDataSeqNum;
-  }
-  return errorObject;
-}
-
-/**
- * getPVErrorFromGqlError will create the error information from an
- * GraphQL error payload.
- * @param payload
- * @param  {} httpDataSeqNum
- */
-function getPVErrorFromGqlError(payload, httpDataSeqNum) {
-  const result = {
-    [URL_ATT_NAME]: getOnURL(payload.url),
-    [TYPE_ATT_NAME]: GQL_EVENT_TYPE,
-    [GQL_ERROR_ATT_NAME]: payload,
-  };
-
-  if (httpDataSeqNum || httpDataSeqNum === 0) {
-    result[PV_SEQ_ATT_NAME] = httpDataSeqNum;
-  }
-
-  return result;
-}
-
-/**
- * getPVErrorFromXMLHttpRequest will create the error information from
- * an HttpRequest error type
- * @param  {} errPayload
- * @param  {} httpDataSeqNum
+ * http response error source.
  */
-function getPVErrorFromXMLHttpRequest(errPayload, httpDataSeqNum) {
-  const errorObject = {
-    [URL_ATT_NAME]: getOnURL(errPayload.responseURL),
-    [TYPE_ATT_NAME]: HTTP_EVENT_TYPE,
-    [HTTP_CODE_ATT_NAME]: errPayload.status,
-  };
-  if (httpDataSeqNum || httpDataSeqNum === 0) {
-    errorObject[PV_SEQ_ATT_NAME] = httpDataSeqNum;
-  }
-  return errorObject;
+function getPVErrorFromResponse(errPayload, seq) {
+    const errorObject = {
+        url: getOnURL(errPayload.url),
+        type: ErrorType.Http,
+        h_code: errPayload.status,
+        gql_err: errPayload.gql_err,
+        err_src: errPayload.type,
+    };
+    if (seq || seq === 0) {
+        errorObject.seq = seq;
+    }
+    return errorObject;
 }
 /**
  * getPVErrorFromErrorEvent will create the error information from an
- * error event type
- * @param  {} errPayload
+ * error event source
  */
 function getPVErrorFromErrorEvent(errPayload) {
-  return {
-    [URL_ATT_NAME]: getOnURL(
-      errPayload.filename || ClientConfig.getInstance().globalUrl,
-    ),
-    [TYPE_ATT_NAME]: JS_EVENT_TYPE,
-    [JS_ERROR_ATT_NAME]: getJSStack(errPayload.error),
-  };
+    return {
+        url: getOnURL(errPayload.filename || ClientConfig.getInstance().globalUrl),
+        type: ErrorType.Js,
+        j_err: getJSStack(errPayload.error),
+        err_src: errPayload.type,
+    };
 }
-
-/** getPVErrorFromErrorLog extracts an error from an error log
- * @param  {} errPayload
- */
+/** getPVErrorFromErrorLog extracts an error from an error log */
 function getPVErrorFromErrorLog(errPayload) {
-  return {
-    [URL_ATT_NAME]: getOnURL(ClientConfig.getInstance().globalUrl),
-    [TYPE_ATT_NAME]: JS_EVENT_TYPE,
-    [JS_ERROR_ATT_NAME]: getJSStack(errPayload),
-  };
+    return {
+        url: ClientConfig.getInstance().globalUrl,
+        type: ErrorType.Js,
+        j_err: getJSStack(errPayload),
+        err_src: PageVisitErrorSource.ErrorLogEvent,
+    };
 }
-
-/**
- * Sets an error message to pvError by a given error event.
- * @param {string} type
- * @param {} pvError
- * @param {} originalError
- */
-function setErrorMessageForUnhandledEvent(type, pvError, originalError) {
-  let detail = null;
-  if (originalError.detail) {
+/** getPVErrorFromCustomType extracts an error from a custom error type */
+function getPVErrorFromCustomType(event) {
+    let updatedEvent = event;
     try {
-      detail = stringifyJSON(originalError.detail);
-    } catch (e) {
-      detail = 'non-serializable';
+        if (window.Event && event instanceof window.Event) {
+            let message = `Fire error event of type ${event.type}.`;
+            const detail = stringifyJSON(event.detail);
+            if (detail) {
+                message += ` Detail: ${detail}.`;
+            }
+            if ('error' in updatedEvent && typeof updatedEvent.error === 'object')
+                updatedEvent = Object.assign(Object.assign({}, updatedEvent), { type: PageVisitErrorSource.ErrorEvent, error: Object.assign(Object.assign({}, updatedEvent.error), { message: getMaxSubstringAllowed(message) }) });
+        }
+        return getPVErrorFromErrorEvent(updatedEvent);
+    }
+    catch (e) {
+        // TODO: report to us that this failed
+        return null;
+    }
+}
+/** Inner method to get the error from a PageVisitErrorInput based on its type */
+function getPVEventErrorInner(event, sequence) {
+    switch (event.type) {
+        case PageVisitErrorSource.XMLHttpRequest:
+        case PageVisitErrorSource.Response: {
+            return getPVErrorFromResponse(event, sequence);
+        }
+        case PageVisitErrorSource.WrappedException:
+        case PageVisitErrorSource.FetchException:
+        case PageVisitErrorSource.UnhandledRejectionError:
+        case PageVisitErrorSource.CustomError:
+        case PageVisitErrorSource.ErrorEvent: {
+            return getPVErrorFromErrorEvent(event);
+        }
+        case PageVisitErrorSource.ErrorLogEvent: {
+            return getPVErrorFromErrorLog(event);
+        }
+        default: {
+            return getPVErrorFromCustomType(event);
+        }
     }
-  }
-  let message = `Fire error event of type ${type}.`;
-  if (detail != null) {
-    message += ` Detail: ${detail}.`;
-  }
-  pvError.j_err.msg = getMaxSubstringAllowed(message); // eslint-disable-line no-param-reassign
 }
-
 /**
  * createPageVisitEventError returns creates an error information
- * object based on the type of error
- * @param  {} type
- * @param  {} errPayload
- * @param  {} httpDataSeqNum
+ * object based on the source of error
  */
-function createPageVisitEventError(type, errPayload, httpDataSeqNum) {
-  // We have seen that errors from requireJS contain the originalError
-  // attribute which is the real error. If we do not extract the originalError we are
-  // not looking at the full error available.
-  // https://github.com/requirejs/requirejs/blob/master/require.js#L172
-  let originalError = errPayload;
-  if (errPayload.error && errPayload.error.originalError) {
-    originalError = errPayload.error.originalError;
-  }
-
-  let pvError = {};
-  switch (type) {
-    case XML_HTTP_REQUEST_ERROR_TYPE: {
-      pvError = getPVErrorFromXMLHttpRequest(originalError, httpDataSeqNum);
-      break;
-    }
-    case ERROR_EVENT_ERROR_TYPE: {
-      pvError = getPVErrorFromErrorEvent(originalError);
-      break;
-    }
-    case RESPONSE_ERROR_TYPE: {
-      pvError = getPVErrorFromResponse(originalError, httpDataSeqNum);
-      break;
-    }
-    case GQL_ERROR_TYPE: {
-      // The error is retrieved from the response of the server
-      // eslint-disable-next-line no-param-reassign
-      type = RESPONSE_ERROR_TYPE;
-      pvError = getPVErrorFromGqlError(originalError, httpDataSeqNum);
-      break;
-    }
-    case WRAPPED_EXCEPTION_ERROR_TYPE: {
-      pvError = getPVErrorFromErrorEvent(originalError);
-      break;
-    }
-    // the fetch handler makes sure that we create the appropriate
-    // error type before sending it for processing thus we do not
-    // need a specific error handler for fetch errors.
-    case FETCH_EXCEPTION_ERROR_TYPE: {
-      pvError = getPVErrorFromErrorEvent(originalError);
-      break;
-    }
-    case ERROR_LOG_EVENT_ERROR_TYPE: {
-      pvError = getPVErrorFromErrorLog(originalError);
-      break;
+function createPageVisitEventError(payload, httpDataSeqNum) {
+    // We have seen that errors from requireJS contain the originalError
+    // attribute which is the real error. If we do not extract the originalError we are
+    // not looking at the full error available.
+    // https://github.com/requirejs/requirejs/blob/master/require.js#L172
+    let originalError = payload;
+    if ('error' in originalError &&
+        originalError.error &&
+        typeof originalError.error === 'object' &&
+        'originalError' in originalError.error &&
+        originalError.error.originalError) {
+        originalError = Object.assign({ type: payload.type }, originalError.error.originalError);
     }
-    case ERROR_EVENT_UNHANDLED_REJECTION_TYPE: {
-      pvError = getPVErrorFromErrorEvent(originalError);
-      break;
-    }
-    case CUSTOM_ERROR_EVENT_TYPE: {
-      pvError = getPVErrorFromErrorEvent(originalError);
-      break;
-    }
-    default: {
-      // TODO: report to us that we sent an invalid type
-      // users have their own type that they will be passing, does not warrant
-      // a failure. We try to process it as an error.
-      try {
-        pvError = getPVErrorFromErrorEvent(originalError);
-        if (window.Event && originalError instanceof window.Event) {
-          // generate error message
-          setErrorMessageForUnhandledEvent(type, pvError, originalError);
-          // override type so metroplex can accept it
-          type = ERROR_EVENT_ERROR_TYPE; // eslint-disable-line no-param-reassign
+    return getPVEventErrorInner(originalError, httpDataSeqNum);
+}
+/** getMsg returns the message of the error if it is a Noibu error */
+function getCollectErrorMsg(pvError) {
+    var _a, _b;
+    switch (pvError.type) {
+        case ErrorType.Js: {
+            if (!((_b = (_a = pvError.j_err) === null || _a === void 0 ? void 0 : _a.frames) === null || _b === void 0 ? void 0 : _b.length)) {
+                return false;
+            }
+            const frames = pvError.j_err.frames;
+            const lowerCapFile = frames[0].file.toLowerCase();
+            const lowerCapMethod = frames[0].mname.toLowerCase();
+            const lowerCapMessage = pvError.j_err.msg.toLowerCase();
+            if (!(lowerCapMessage.includes('input.noibu') ||
+                lowerCapMessage.includes('input.b.noibu') ||
+                (lowerCapFile.includes('noibu') && !lowerCapMethod.includes('nbuwrapper')))) {
+                return false;
+            }
+            return pvError.j_err.msg;
+        }
+        case ErrorType.Http: {
+            if (!NOIBU_INPUT_URLS.some(url => { var _a, _b; return (_b = (_a = pvError.url) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, url); })) {
+                return false;
+            }
+            return 'Noibu endpoint failed';
         }
-      } catch (e) {
-        // TODO: report to us that this failed
-        return null;
-      }
     }
-  }
-
-  // setting the source of this error to be the type
-  pvError[ERROR_SOURCE_ATT_NAME] = type;
-  return pvError;
+    return false;
 }
-
 /**
  * determines if an error is a collect error
- * @param  {} 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]) {
-      const frames = pvError[JS_ERROR_ATT_NAME][JS_STACK_FRAMES_ATT_NAME];
-      if (frames && frames.length > 0) {
-        const lowerCapFile = frames[0][JS_STACK_FILE_ATT_NAME].toLowerCase();
-        const lowerCapMethod =
-          frames[0][JS_STACK_METHOD_ATT_NAME].toLowerCase();
-
-        if (
-          lowerCapFile.includes('noibu') &&
-          !lowerCapFile.includes('examplenoibureactnativeapp') &&
-          !lowerCapMethod.includes('nbuwrapper')
-        ) {
-          // if the first file in the stack is Noibu then we do not
-          // queue this error for analytics, we send it to another
-          // endpoint to alert us
-          ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-            pvError,
-            false,
-            SEVERITY.error,
-          );
-          return true;
+    return __awaiter(this, void 0, void 0, function* () {
+        // checking if this error originated from the Noibu script
+        const msg = getCollectErrorMsg(pvError);
+        if (msg) {
+            return ClientConfig.getInstance().postInternalError({ msg, pvError }, false, SEVERITY.error);
         }
-      }
+        return false;
+    });
+}
+/** Saves the error to the Error queue */
+function saveErrorToPagevisit(payload, httpDataSeqNum) {
+    // We do not want to process errors events as errors (yet)
+    if (payload.type === PageVisitErrorSource.Event) {
+        return;
     }
-    // checking if the message contains noibu.
-    if (pvError[JS_STACK_MESSAGE_ATT_NAME]) {
-      const lowerCapMessage = pvError[JS_STACK_MESSAGE_ATT_NAME].toLowerCase();
-      // we do not want all errors that contain noibu in their messages to be ignored
-      // only the errors that we are confident are not impact the user.
-      if (
-        lowerCapMessage.includes('input.noibu') ||
-        lowerCapMessage.includes('input.b.noibu')
-      ) {
-        ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-          pvError,
-          false,
-          SEVERITY.error,
-        );
-        return true;
-      }
+    const pvError = createPageVisitEventError(payload, httpDataSeqNum);
+    // making sure we have the error object defined
+    if (!pvError || !pvError.url) {
+        return;
     }
-  } else if (
-    pvError[TYPE_ATT_NAME] === HTTP_EVENT_TYPE &&
-    pvError[URL_ATT_NAME]
-  ) {
-    const currURL = pvError[URL_ATT_NAME];
-    if (typeof currURL === 'string') {
-      // this means that our endpoing has failed and we need to
-      // send an alert to stack driver
-      for (let i = 0; i < NOIBU_INPUT_URLS.length; i += 1) {
-        const inputURL = NOIBU_INPUT_URLS[i];
-        if (currURL.includes(inputURL)) {
-          ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-            pvError,
-            false,
-            SEVERITY.error,
-          );
-          return true;
+    const currErrURL = pvError.url;
+    // We need valid URLs in order to check their blacklist status
+    if (isValidURL(currErrURL)) {
+        const urlOb = new URL(currErrURL);
+        // if the domain is blacklisted we drop the error
+        if (urlOb.hostname in BLOCKLISTED_DOMAINS) {
+            return;
         }
-      }
     }
-  }
-
-  return false;
-}
-
-/** Saves the error to the ErrorQueue
- * @param  {} type
- * @param  {} payload
- * @param  {} [httpDataSeqNum]
- */
-function saveErrorToPagevisit(type, payload, httpDataSeqNum) {
-  // We do not want to process errors events as errors (yet)
-  if (type === EVENT_ERROR_TYPE) {
-    return;
-  }
-  const pvError = createPageVisitEventError(type, payload, httpDataSeqNum);
-
-  // making sure we have the error object defined
-  if (!pvError || !pvError[URL_ATT_NAME]) {
-    return;
-  }
-
-  const currErrURL = pvError[URL_ATT_NAME];
-
-  // We need valid URLs in order to check their blacklist status
-  if (isValidURL(currErrURL)) {
-    const urlOb = new URL(currErrURL);
-
-    // if the domain is blacklisted we drop the error
-    if (urlOb.hostname in BLOCKLISTED_DOMAINS) {
-      return;
-    }
-  }
-
-  if (isErrorCollectedByNoibu(pvError)) {
-    return;
-  }
-
-  // we register an error event
-  StoredMetrics.getInstance().addError();
-  // debounce event
-  EventDebouncer.getInstance().addEvent(pvError, ERROR_EVENT_TYPE);
+    isErrorCollectedByNoibu(pvError).then(isCollected => {
+        if (isCollected) {
+            return;
+        }
+        StoredMetrics.getInstance().addError();
+        EventDebouncer.getInstance().debounce({
+            type: EventType.Error,
+            err: pvError,
+        });
+    });
 }
 
 export { getOnURL, isErrorCollectedByNoibu, saveErrorToPagevisit };

package/dist/react/ErrorBoundary.js

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import uuid from 'react-native-uuid';
-import InputManager from '../api/inputManager.js';
+import InputManager from '../api/InputManager.js';
 
 // initial state variables
 const INITIAL_STATE = {
@@ -9,17 +9,14 @@ const INITIAL_STATE = {
     eventId: null,
 };
 /**
- * @description A ErrorBoundary component that logs errors to Noibu. Requires React >= 16.
+ * @description Target ErrorBoundary component that logs errors to Noibu. Requires React >= 16.
  * @extends {Component<ErrorBoundaryProps, ErrorBoundaryState>}
  */
 class ErrorBoundary extends React.Component {
     constructor() {
         super(...arguments);
         this.state = INITIAL_STATE;
-        /**
-         * Callback from fallback to reset the error boundary
-         * @param  {} =>void=(
-         */
+        /** Callback from fallback to reset the error boundary */
         this.resetErrorBoundary = () => {
             const { onReset } = this.props;
             const { error, componentStack, eventId } = this.state;