@luciq/react-native 18.0.0

package/src/utils/LuciqUtils.ts

@@ -0,0 +1,417 @@
+import { Platform } from 'react-native';
+import parseErrorStackLib, {
+  ExtendedError,
+  StackFrame,
+} from 'react-native/Libraries/Core/Devtools/parseErrorStack';
+
+import type { NavigationState as NavigationStateV5, PartialState } from '@react-navigation/native';
+import type { NavigationState as NavigationStateV4 } from 'react-navigation';
+
+import type { CrashData } from '../native/NativeCrashReporting';
+import { NativeCrashReporting } from '../native/NativeCrashReporting';
+import type { NetworkData } from './XhrNetworkInterceptor';
+import { NativeLuciq } from '../native/NativeLuciq';
+import { NativeAPM } from '../native/NativeAPM';
+import * as NetworkLogger from '../modules/NetworkLogger';
+import {
+  NativeNetworkLogger,
+  NativeNetworkLoggerEvent,
+  NetworkListenerType,
+  NetworkLoggerEmitter,
+} from '../native/NativeNetworkLogger';
+
+type ApmNetworkFlags = {
+  isNativeInterceptionFeatureEnabled: boolean;
+  hasAPMNetworkPlugin: boolean;
+  shouldEnableNativeInterception: boolean;
+};
+
+let apmFlags: ApmNetworkFlags = {
+  isNativeInterceptionFeatureEnabled: false,
+  hasAPMNetworkPlugin: false,
+  shouldEnableNativeInterception: false,
+};
+
+export function setApmNetworkFlagsIfChanged(flags: ApmNetworkFlags): boolean {
+  if (
+    flags.hasAPMNetworkPlugin === apmFlags.hasAPMNetworkPlugin &&
+    flags.isNativeInterceptionFeatureEnabled === apmFlags.isNativeInterceptionFeatureEnabled &&
+    flags.shouldEnableNativeInterception === apmFlags.shouldEnableNativeInterception
+  ) {
+    return false;
+  }
+  apmFlags = flags;
+  return true;
+}
+
+export const parseErrorStack = (error: ExtendedError): StackFrame[] => {
+  return parseErrorStackLib(error);
+};
+
+export const getCrashDataFromError = (error: Error) => {
+  const jsStackTrace = getStackTrace(error);
+
+  const jsonObject: CrashData = {
+    message: error.name + ' - ' + error.message,
+    e_message: error.message,
+    e_name: error.name,
+    os: Platform.OS,
+    platform: 'react_native',
+    exception: jsStackTrace,
+  };
+  return jsonObject;
+};
+
+export const getActiveRouteName = (navigationState: NavigationStateV4): string | null => {
+  if (!navigationState) {
+    return null;
+  }
+  const route = navigationState.routes[navigationState.index];
+  // dive into nested navigators
+  if (route.routes) {
+    return getActiveRouteName(route);
+  }
+  return route.routeName;
+};
+
+export function getFullRoute(state: NavigationStateV5 | PartialState<NavigationStateV5>): string {
+  try {
+    if (!state.routes[state.index!].state) {
+      return state.routes[state.index!].name;
+    }
+    return getFullRoute(state.routes[state.index!].state!);
+  } catch (e) {
+    return '';
+  }
+}
+
+export const getStackTrace = (e: ExtendedError): StackFrame[] => {
+  let jsStackTrace;
+  if (Platform.hasOwnProperty('constants')) {
+    // RN version >= 0.63
+    if (Platform.constants.reactNativeVersion.minor >= 64) {
+      // RN version >= 0.64 -> Stacktrace as string
+      // @ts-ignore
+      jsStackTrace = parseErrorStackLib(e.stack);
+    }
+    // RN version == 0.63 -> Stacktrace as string
+    else {
+      jsStackTrace = parseErrorStackLib(e);
+    }
+  }
+  // RN version < 0.63 -> Stacktrace as string
+  else {
+    jsStackTrace = parseErrorStackLib(e);
+  }
+  return jsStackTrace;
+};
+
+export const captureJsErrors = () => {
+  if (!process.env.JEST_WORKER_ID) {
+    if (__DEV__) {
+      return;
+    }
+  }
+
+  const originalErrorHandler = ErrorUtils.getGlobalHandler();
+
+  const luciqErrorHandler = (err: any, _isFatal?: boolean): Promise<void> => {
+    return sendCrashReport(err, NativeCrashReporting.sendJSCrash);
+  };
+
+  ErrorUtils.setGlobalHandler(async (err, isFatal) => {
+    await luciqErrorHandler(err, isFatal);
+
+    if (process.env.JEST_WORKER_ID) {
+      return;
+    }
+    originalErrorHandler(err, isFatal);
+  });
+};
+
+export const stringifyIfNotString = (input: unknown) => {
+  return typeof input === 'string' ? input : JSON.stringify(input);
+};
+
+/**
+ * Sends crash report to Luciq's servers based on @param sendFunction
+ *
+ * @param error Error object to be sent to Luciq's servers
+ * @param remoteSenderCallback Function to send the crash report to Luciq's servers
+ *
+ * @example
+ * `sendCrashReport(error, NativeCrashReporting.sendHandledJSCrash);`
+ * or
+ * `sendCrashReport(error, NativeCrashReporting.sendJSCrash);`
+ *
+ */
+export async function sendCrashReport(
+  error: ExtendedError,
+  remoteSenderCallback: (json: CrashData | string) => Promise<void>,
+) {
+  const jsonObject = getCrashDataFromError(error);
+
+  if (Platform.OS === 'android') {
+    return remoteSenderCallback(JSON.stringify(jsonObject));
+  }
+
+  return remoteSenderCallback(jsonObject);
+}
+/**
+ * Generate random 32 bit unsigned integer Hexadecimal (8 chars) lower case letters
+ * Should not return all zeros
+ */
+export const generateTracePartialId = () => {
+  let randomNumber: number;
+  let hexString: string;
+
+  do {
+    randomNumber = Math.floor(Math.random() * 0xffffffff);
+    hexString = randomNumber.toString(16).padStart(8, '0');
+  } while (hexString === '00000000');
+
+  return { numberPartilId: randomNumber, hexStringPartialId: hexString.toLowerCase() };
+};
+/**
+ * Generate W3C header in the format of {version}-{trace-id}-{parent-id}-{trace-flag}
+ * @param networkStartTime
+ * @returns w3c header
+ */
+export const generateW3CHeader = (networkStartTime: number) => {
+  const { hexStringPartialId, numberPartilId } = generateTracePartialId();
+
+  const TRACESTATE = '4942472d';
+  const VERSION = '00';
+  const TRACE_FLAG = '01';
+
+  const timestampInSeconds = Math.floor(networkStartTime.valueOf() / 1000);
+  const hexaDigitsTimestamp = timestampInSeconds.toString(16).toLowerCase();
+  const traceId = `${hexaDigitsTimestamp}${hexStringPartialId}${hexaDigitsTimestamp}${hexStringPartialId}`;
+  const parentId = `${TRACESTATE}${hexStringPartialId}`;
+
+  return {
+    timestampInSeconds,
+    partialId: numberPartilId,
+    w3cHeader: `${VERSION}-${traceId}-${parentId}-${TRACE_FLAG}`,
+  };
+};
+
+export function isContentTypeNotAllowed(contentType: string) {
+  const allowed = [
+    'application/protobuf',
+    'application/json',
+    'application/xml',
+    'text/xml',
+    'text/html',
+    'text/plain',
+  ];
+
+  return allowed.every((type) => !contentType.includes(type));
+}
+
+export const reportNetworkLog = (network: NetworkData) => {
+  if (Platform.OS === 'android') {
+    const requestHeaders = JSON.stringify(network.requestHeaders);
+    const responseHeaders = JSON.stringify(network.responseHeaders);
+
+    NativeLuciq.networkLogAndroid(
+      network.url,
+      network.requestBody,
+      network.responseBody,
+      network.method,
+      network.responseCode,
+      requestHeaders,
+      responseHeaders,
+      network.duration,
+    );
+    if (
+      !apmFlags.isNativeInterceptionFeatureEnabled ||
+      !apmFlags.hasAPMNetworkPlugin ||
+      !apmFlags.shouldEnableNativeInterception
+    ) {
+      NativeAPM.networkLogAndroid(
+        network.startTime,
+        network.duration,
+        requestHeaders,
+        network.requestBody,
+        network.requestBodySize,
+        network.method,
+        network.url,
+        network.requestContentType,
+        responseHeaders,
+        network.responseBody,
+        network.responseBodySize,
+        network.responseCode,
+        network.contentType,
+        network.errorDomain,
+        {
+          isW3cHeaderFound: network.isW3cHeaderFound,
+          partialId: network.partialId,
+          networkStartTimeInSeconds: network.networkStartTimeInSeconds,
+          w3cGeneratedHeader: network.w3cGeneratedHeader,
+          w3cCaughtHeader: network.w3cCaughtHeader,
+        },
+        network.gqlQueryName,
+        network.serverErrorMessage,
+      );
+    }
+  } else {
+    NativeLuciq.networkLogIOS(
+      network.url,
+      network.method,
+      network.requestBody,
+      network.requestBodySize,
+      network.responseBody,
+      network.responseBodySize,
+      network.responseCode,
+      network.requestHeaders,
+      network.responseHeaders,
+      network.contentType,
+      network.errorDomain,
+      network.errorCode,
+      network.startTime,
+      network.duration,
+      network.gqlQueryName,
+      network.serverErrorMessage,
+      {
+        isW3cHeaderFound: network.isW3cHeaderFound,
+        partialId: network.partialId,
+        networkStartTimeInSeconds: network.networkStartTimeInSeconds,
+        w3cGeneratedHeader: network.w3cGeneratedHeader,
+        w3cCaughtHeader: network.w3cCaughtHeader,
+      },
+    );
+  }
+};
+
+/**
+ * @internal
+ * This method is for internal use only.
+ */
+export function registerObfuscationListener() {
+  NetworkLogger.registerNetworkLogsListener(
+    NetworkListenerType.obfuscation,
+    async (networkSnapshot) => {
+      const _networkDataObfuscationHandler = NetworkLogger.getNetworkDataObfuscationHandler();
+      if (_networkDataObfuscationHandler) {
+        networkSnapshot = await _networkDataObfuscationHandler(networkSnapshot);
+      }
+      updateNetworkLogSnapshot(networkSnapshot);
+    },
+  );
+}
+
+/**
+ * @internal
+ * This method is for internal use only.
+ */
+export function registerFilteringListener(filterExpression: string) {
+  NetworkLogger.registerNetworkLogsListener(
+    NetworkListenerType.filtering,
+    async (networkSnapshot) => {
+      // eslint-disable-next-line no-new-func
+      const predicate = Function('network', 'return ' + filterExpression);
+      const value = predicate(networkSnapshot);
+      if (Platform.OS === 'ios') {
+        // For iOS True == Request will be saved, False == will be ignored
+        NativeNetworkLogger.setNetworkLoggingRequestFilterPredicateIOS(networkSnapshot.id, !value);
+      } else {
+        // For Android Setting the [url] to an empty string will ignore the request;
+        if (value) {
+          networkSnapshot.url = '';
+          updateNetworkLogSnapshot(networkSnapshot);
+        }
+      }
+    },
+  );
+}
+
+/**
+ * @internal
+ * This method is for internal use only.
+ */
+export function registerFilteringAndObfuscationListener(filterExpression: string) {
+  NetworkLogger.registerNetworkLogsListener(NetworkListenerType.both, async (networkSnapshot) => {
+    // eslint-disable-next-line no-new-func
+    const predicate = Function('network', 'return ' + filterExpression);
+    const value = predicate(networkSnapshot);
+    if (Platform.OS === 'ios') {
+      // For iOS True == Request will be saved, False == will be ignored
+      NativeNetworkLogger.setNetworkLoggingRequestFilterPredicateIOS(networkSnapshot.id, !value);
+    } else {
+      // For Android Setting the [url] to an empty string will ignore the request;
+      if (value) {
+        networkSnapshot.url = '';
+        updateNetworkLogSnapshot(networkSnapshot);
+      }
+    }
+    if (!value) {
+      const _networkDataObfuscationHandler = NetworkLogger.getNetworkDataObfuscationHandler();
+      if (_networkDataObfuscationHandler) {
+        networkSnapshot = await _networkDataObfuscationHandler(networkSnapshot);
+      }
+      updateNetworkLogSnapshot(networkSnapshot);
+    }
+  });
+}
+
+/**
+ * @internal
+ * This method is for internal use only.
+ */
+export function checkNetworkRequestHandlers() {
+  const obfuscationHandler = NetworkLogger.getNetworkDataObfuscationHandler();
+  const hasFilterExpression = NetworkLogger.hasRequestFilterExpression();
+
+  if (hasFilterExpression && obfuscationHandler) {
+    // Register listener that handles both (Filtering & Obfuscation)
+    registerFilteringAndObfuscationListener(NetworkLogger.getRequestFilterExpression());
+    return;
+  }
+  if (obfuscationHandler) {
+    // Register listener that handles only (Obfuscation)
+    registerObfuscationListener();
+    return;
+  }
+
+  if (hasFilterExpression) {
+    // Register listener that handles only (Filtering)
+    registerFilteringListener(NetworkLogger.getRequestFilterExpression());
+    return;
+  }
+}
+export function resetNativeObfuscationListener() {
+  if (Platform.OS === 'android') {
+    NativeNetworkLogger.resetNetworkLogsListener();
+  }
+  NetworkLoggerEmitter.removeAllListeners(NativeNetworkLoggerEvent.NETWORK_LOGGER_HANDLER);
+}
+
+/**
+ * @internal
+ * This method is for internal use only.
+ */
+export function updateNetworkLogSnapshot(networkSnapshot: NetworkData) {
+  NativeNetworkLogger.updateNetworkLogSnapshot(
+    networkSnapshot.url,
+    networkSnapshot.id,
+    networkSnapshot.requestBody,
+    networkSnapshot.responseBody,
+    networkSnapshot.responseCode ?? 200,
+    networkSnapshot.requestHeaders,
+    networkSnapshot.responseHeaders,
+  );
+}
+
+export default {
+  parseErrorStack,
+  captureJsErrors,
+  getActiveRouteName,
+  getFullRoute,
+  getStackTrace,
+  stringifyIfNotString,
+  sendCrashReport,
+  reportNetworkLog,
+  generateTracePartialId,
+  generateW3CHeader,
+};

package/src/utils/UnhandledRejectionTracking.ts

@@ -0,0 +1,118 @@
+import tracking, { RejectionTrackingOptions } from 'promise/setimmediate/rejection-tracking';
+import { sendCrashReport } from './LuciqUtils';
+import { NativeCrashReporting } from '../native/NativeCrashReporting';
+import { NonFatalErrorLevel } from './Enums';
+import { Logger } from './logger';
+
+export interface HermesInternalType {
+  enablePromiseRejectionTracker?: (options?: RejectionTrackingOptions) => void;
+  hasPromise?: () => boolean;
+}
+
+/**
+ * A typed version of the `HermesInternal` global object with the properties
+ * we use.
+ */
+function _getHermes(): HermesInternalType | null {
+  return (global as any).HermesInternal;
+}
+
+/**
+ * Checks whether the Promise object is provided by Hermes.
+ *
+ * @returns whether the `Promise` object is provided by Hermes.
+ */
+function _isHermesPromise() {
+  const hermes = _getHermes();
+  const hasPromise = hermes?.hasPromise?.() === true;
+  const canTrack = hermes?.enablePromiseRejectionTracker != null;
+
+  return hasPromise && canTrack;
+}
+
+/**
+ * Enables unhandled Promise rejection tracking in Hermes.
+ *
+ * @param options Rejection tracking options.
+ */
+function _enableHermesRejectionTracking(options?: RejectionTrackingOptions) {
+  const hermes = _getHermes();
+
+  hermes!.enablePromiseRejectionTracker!(options);
+}
+
+/**
+ * Enables unhandled Promise rejection tracking in the default `promise` polyfill.
+ *
+ * @param options Rejection tracking options.
+ */
+function _enableDefaultRejectionTracking(options?: RejectionTrackingOptions) {
+  tracking.enable(options);
+}
+
+/**
+ * Tracks whether an unhandled Promise rejection happens and reports it.
+ */
+export function captureUnhandledRejections() {
+  const options: RejectionTrackingOptions = {
+    allRejections: true,
+    onUnhandled: _onUnhandled,
+  };
+
+  if (_isHermesPromise()) {
+    _enableHermesRejectionTracking(options);
+  } else {
+    _enableDefaultRejectionTracking(options);
+  }
+}
+
+/**
+ * The callback passed in the rejection tracking options to report unhandled
+ * Promise rejection
+ */
+function _onUnhandled(id: number, rejection: unknown) {
+  _originalOnUnhandled(id, rejection);
+
+  if (__DEV__) {
+    return;
+  }
+
+  if (rejection instanceof Error) {
+    sendCrashReport(rejection, (error) =>
+      NativeCrashReporting.sendHandledJSCrash(error, null, null, NonFatalErrorLevel.error),
+    );
+  }
+}
+
+/* istanbul ignore next */
+/**
+ * The default unhandled promise rejection handler set by React Native.
+ *
+ * In fact, this is copied from the React Native repo but modified to work well
+ * with our static analysis setup.
+ *
+ * https://github.com/facebook/react-native/blob/f2447e6048a6b519c3333767d950dbf567149b75/packages/react-native/Libraries/promiseRejectionTrackingOptions.js#L15-L49
+ */
+function _originalOnUnhandled(id: number, rejection: unknown = {}) {
+  let message: string;
+  let stack: string | undefined;
+
+  const stringValue = Object.prototype.toString.call(rejection);
+  if (stringValue === '[object Error]') {
+    message = Error.prototype.toString.call(rejection);
+    const error = rejection as Error;
+    stack = error.stack;
+  } else {
+    try {
+      message = require('pretty-format')(rejection);
+    } catch {
+      message = typeof rejection === 'string' ? rejection : JSON.stringify(rejection);
+    }
+  }
+
+  const warning =
+    `Possible Unhandled Promise Rejection (id: ${id}):\n` +
+    `${message ?? ''}\n` +
+    (stack == null ? '' : stack);
+  Logger.warn(warning);
+}