noibu-react-native 0.2.2 → 0.2.4

package/dist/monitors/requestMonitor.js

@@ -1,401 +0,0 @@
-import 'react-native/Libraries/Network/fetch';
-import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
-import { PageVisitEventHTTP, isHttpCodeFailure } from '../pageVisit/pageVisitEventHTTP.js';
-import { propWriteableOrMadeWriteable, replace } from '../utils/object.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
-
-/**
- * Called in the fetch() wrapper function, this specifically gets called after the promises which
- * return the request and response body complete.
- * @param {object} request a Request object
- * @param {object} response a Response object
- * @param {object} options the options parameter from the original fetch() call
- * @param {string[]} bodyStrings an array of string HTTP bodies from the wrapped fetch() function.
- * [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(
-  request,
-  response,
-  options,
-  bodyStrings,
-  url,
-  method,
-  shouldCollectPayload,
-) {
-  noibuLog('_handleFetchOnPromiseCompletion', method, url);
-  let reqBody; //
-  let reqHeaders = new Map();
-  let respHeaders = new Map();
-  if (bodyStrings[1]) {
-    // Get reqBody from request obj if it exists
-    // I don't like this notation, but the linter enforces it.
-    // This is the same as reqBody = values[1]
-    [, reqBody] = bodyStrings;
-
-    // Get reqHeaders from request obj
-    if (request.headers) {
-      reqHeaders = HTTPDataBundler.headersMapFromIterable(
-        request.headers.entries(),
-      );
-    }
-  }
-  // Get reqBody from options if it hasn't been defined above.
-  // Double-equals null check on reqBody to get null or undefined but not an empty string
-  if (reqBody == null && !!options && !!options.body) reqBody = options.body;
-
-  // Get reqHeaders from options.headers
-  if (reqHeaders.size < 1 && !!options && !!options.headers) {
-    // Two cases here: headers will either be a simple object (key/value), or
-    // a Headers type object.
-
-    // Case 1: headers has a .entries() property, it is a Header object
-    if (options.headers instanceof Headers) {
-      reqHeaders = HTTPDataBundler.headersMapFromIterable(
-        options.headers.entries(),
-      );
-    }
-    // Case 2: headers is a simple object, same logic as above but we call it as
-    // Object.entries()
-    else {
-      reqHeaders = HTTPDataBundler.headersMapFromIterable(
-        Object.entries(options.headers),
-      );
-    }
-  }
-
-  // response.headers will always be a Headers object.
-  if (!!response && !!response.headers) {
-    respHeaders = HTTPDataBundler.headersMapFromIterable(
-      response.headers.entries(),
-    );
-  }
-
-  return HTTPDataBundler.getInstance().bundleHTTPData(
-    url,
-    reqHeaders,
-    reqBody,
-    respHeaders,
-    bodyStrings[0],
-    method,
-    shouldCollectPayload,
-  );
-}
-
-/**
- * Returns the parameters to pass the PageVisitEventHTTP constructor. Specific to the fetch wrapper.
- * @param {object} request a Request object
- * @param {object} response a Response object cloned() from the original
- * @param {string} method the method used in the fetch call
- * @param {string} url the URL of the request
- * @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 {Promise<string>} requestTextPromise
- * @returns an array in the form [httpEvent, httpData]
- */
-async function _buildHttpEventDataObjectsForFetch(
-  request,
-  response,
-  method,
-  url,
-  options,
-  respTime,
-  requestTextPromise,
-) {
-  noibuLog('_buildHttpEventDataObjectsForFetch started', method, url);
-  const httpEvent = {
-    [HTTP_METHOD_ATT_NAME]: method,
-    [HTTP_RESP_CODE_ATT_NAME]: response.status,
-    [URL_ATT_NAME]: url,
-    [HTTP_RESP_TIME_ATT_NAME]: respTime,
-  };
-
-  let httpData = null;
-  // Only get the bodies of the request and response if the URL is one we care about.
-  if (HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
-    // add response payload length, if any
-    if (response && response.headers) {
-      const contentLength = HTTPDataBundler.getInstance().contentLength(
-        response.headers,
-      );
-      if (contentLength > 0) {
-        httpEvent[HTTP_RESP_LENGTH_ATT_NAME] = contentLength;
-      }
-    }
-
-    let responseText = '';
-    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);
-
-    // Array to pass to Promise.all(). We conditionally include requestTextPromise as a
-    // second element if it was defined earlier.
-    const promises = [
-      responseTextPromise,
-      ...(requestTextPromise ? [requestTextPromise] : []),
-    ];
-
-    // Wait on the promises for the response and the request (if applicable) to resolve,
-    // then call our handler
-    await Promise.all(promises)
-      .then(data =>
-        _handleFetchOnPromiseCompletion(
-          request,
-          response,
-          options,
-          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];
-}
-
-/**
- * Handles fetch failure
- * @param  {} err
- * @param  {} url
- */
-function handleFetchFailure(err, url) {
-  if (!err) {
-    return;
-  }
-
-  // we do not need this error if we cannot extract both the message and stack
-  if (!err.message || !err.stack) {
-    return;
-  }
-
-  // making sure we have a url
-  const checkedURL = !url ? '' : url;
-  const errorFromFetch = new Error();
-  errorFromFetch.stack = err.stack;
-  const urlMessage = checkedURL.trim() === '' ? '' : ` on url ${checkedURL}`;
-  errorFromFetch.message = `${err.message}${urlMessage}`;
-  const errorPayload = {
-    error: errorFromFetch,
-  };
-  saveErrorToPagevisit(FETCH_EXCEPTION_ERROR_TYPE, errorPayload);
-}
-
-/**
- * Setting up the wrapper around fetch functions to try and
- * catch http errors
- */
-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',
-    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 nbuGlobalFetchWrapper(resource, options) {
-        let method;
-        let url;
-
-        // These two variables will only be defined if the resource param is a request object.
-        // request, if defined, will be a clone of the request object
-        let request;
-        // requestTextPromise, if defined, will be a promise obtained from request that resolves
-        // to the response body as text
-        let requestTextPromise;
-
-        // 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) {
-            method = 'GET';
-            url = '';
-          } else {
-            if (resource.method) {
-              method = resource.method;
-              url = resource.url;
-            } else {
-              // If options or options.method is missing, fallback to GET.
-              method = options && options.method ? options.method : 'GET';
-              url = resource.toString() ? resource.toString() : '';
-            }
-            // resource is defined
-            // Two possibilities: resource could be either any object with a .toString() function,
-            // or it could be a Request object. If it's a Request, we'll have to clone it, and read
-            // its body asynchronously. We check for the existence of a .method property on the
-            // resource to check whether it is a Request object.
-            if (
-              HTTPDataBundler.getInstance().shouldCollectPayloadForURL(url) &&
-              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) {
-          ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-            `Error in fetch() wrapper: ${e}`,
-            false,
-            SEVERITY.error,
-          );
-        }
-
-        // 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,
-          resource,
-          options,
-        );
-        // not using safePerformanceNow as there is a 75% hit with using it.
-        // We don't want every request to get impacted by this.
-        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 {
-              const graphqlResponse = response.clone();
-              const httpEventDataResponse = response.clone();
-              const pageVisitErrorResponse = response.clone();
-
-              const gqlError = await GqlErrorValidator.fromFetch(
-                url,
-                options,
-                request,
-                graphqlResponse,
-              );
-
-              const rEndedAt = new Date();
-              const respTime = Math.abs(rEndedAt - rCreatedAt);
-              const [httpEvent, httpData] =
-                await _buildHttpEventDataObjectsForFetch(
-                  request,
-                  httpEventDataResponse,
-                  method,
-                  url,
-                  options,
-                  respTime,
-                  requestTextPromise,
-                );
-
-              let pageVisitEventHTTP = new PageVisitEventHTTP(
-                httpEvent,
-                httpData,
-              );
-              pageVisitEventHTTP.saveHTTPEvent();
-
-              const seq =
-                pageVisitEventHTTP.httpData &&
-                pageVisitEventHTTP.httpData[PV_SEQ_ATT_NAME];
-
-              if (isHttpCodeFailure(response.status)) {
-                saveErrorToPagevisit(
-                  RESPONSE_ERROR_TYPE,
-                  pageVisitErrorResponse,
-                  seq,
-                );
-              }
-
-              if (gqlError) {
-                gqlError.forEach(error =>
-                  saveErrorToPagevisit(GQL_ERROR_TYPE, error, seq),
-                );
-              }
-
-              // helping gc
-              pageVisitEventHTTP = null;
-            } catch (e) {
-              // Catch errors with our logic in the .then() callback above
-              ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(
-                `Error in custom fetch() callback: ${e}`,
-                false,
-                SEVERITY.error,
-              );
-            }
-          })
-          .catch(err => {
-            // Catch errors in the call to the original fetch() implementation
-            handleFetchFailure(err, url);
-          });
-
-        // Can't put this inside finally as linter does not allow return statements inside finally.
-        return promiseFromOriginalFetch;
-      },
-  );
-}
-/**
- * Monitors all requests
- */
-function monitorRequests() {
-  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/pageVisitEventHTTP.d.ts

@@ -1,18 +0,0 @@
-/**
- * Determines if a response is a failure
- * @param  {number} code
- */
-export function isHttpCodeFailure(code: number): boolean;
-/** Class representing a PageVisitEventHTTP */
-export class PageVisitEventHTTP {
-    /**
-     * Creates an instance of the http event for the pv
-     * @param  {} httpEvent
-     * @param  {} httpData
-     */
-    constructor(httpEvent: any, httpData: any);
-    httpEvent: any;
-    httpData: any;
-    /** Saves the HTTP event to the pageVisit Queue */
-    saveHTTPEvent(): void;
-}

package/dist/types/PageVisit.d.ts

@@ -1,22 +0,0 @@
-export type Event = {
-    type: string;
-};
-export type EventPayload = Partial<{
-    txt: string;
-    src: string;
-    hid: string;
-    tag: string;
-    type: string;
-    class: string;
-    pvp: string;
-}>;
-export interface JError {
-    frames: JStackFrame[];
-    msg: string;
-}
-export interface JStackFrame {
-    column?: number;
-    line: string;
-    mname: string;
-    file: string;
-}

package/dist/types/ReactNative.d.ts

@@ -1,4 +0,0 @@
-export interface RNNode {
-    memoizedProps: any;
-    elementType: string;
-}

package/dist/types/globals.d.ts

@@ -1,45 +0,0 @@
-declare global {
-    const METROPLEX_BASE_SOCKET_URL: string;
-    const BETA_METROPLEX_BASE_SOCKET_URL: string;
-    const METROPLEX_BASE_HTTP_URL: string;
-    const BETA_METROPLEX_BASE_HTTP_URL: string;
-    const CURR_ENV: string;
-    const MAX_PAGE_VISIT_BUFFER_SIZE: string;
-    const DEBOUNCE_PV_POST_ON_CLICK_FREQ: string;
-    const VID_POST_FREQUENCY: string;
-    const PAGEVISIT_POST_FREQUENCY: string;
-    const WRITE_TO_METROPLEX_FREQUENCY: number;
-    const CLIENT_SCRIPT_ID: string;
-    const MAX_METROPLEX_RECONNECTION_NUMBER: number;
-    const METROPLEX_CONSECUTIVE_CONNECTION_DELAY: number;
-    const SCRIPT_ID: string;
-    const ENABLE_LOGGING: string;
-    const ENV: string;
-    const DEVICE_ENV: string | undefined;
-    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?: (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;
-}
-export {};