@luciq/react-native 18.0.0

package/dist/utils/LuciqUtils.d.ts

@@ -0,0 +1,97 @@
+import { 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 type { NetworkData } from './XhrNetworkInterceptor';
+type ApmNetworkFlags = {
+    isNativeInterceptionFeatureEnabled: boolean;
+    hasAPMNetworkPlugin: boolean;
+    shouldEnableNativeInterception: boolean;
+};
+export declare function setApmNetworkFlagsIfChanged(flags: ApmNetworkFlags): boolean;
+export declare const parseErrorStack: (error: ExtendedError) => StackFrame[];
+export declare const getCrashDataFromError: (error: Error) => CrashData;
+export declare const getActiveRouteName: (navigationState: NavigationStateV4) => string | null;
+export declare function getFullRoute(state: NavigationStateV5 | PartialState<NavigationStateV5>): string;
+export declare const getStackTrace: (e: ExtendedError) => StackFrame[];
+export declare const captureJsErrors: () => void;
+export declare const stringifyIfNotString: (input: unknown) => string;
+/**
+ * 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 declare function sendCrashReport(error: ExtendedError, remoteSenderCallback: (json: CrashData | string) => Promise<void>): Promise<void>;
+/**
+ * Generate random 32 bit unsigned integer Hexadecimal (8 chars) lower case letters
+ * Should not return all zeros
+ */
+export declare const generateTracePartialId: () => {
+    numberPartilId: number;
+    hexStringPartialId: string;
+};
+/**
+ * Generate W3C header in the format of {version}-{trace-id}-{parent-id}-{trace-flag}
+ * @param networkStartTime
+ * @returns w3c header
+ */
+export declare const generateW3CHeader: (networkStartTime: number) => {
+    timestampInSeconds: number;
+    partialId: number;
+    w3cHeader: string;
+};
+export declare function isContentTypeNotAllowed(contentType: string): boolean;
+export declare const reportNetworkLog: (network: NetworkData) => void;
+/**
+ * @internal
+ * This method is for internal use only.
+ */
+export declare function registerObfuscationListener(): void;
+/**
+ * @internal
+ * This method is for internal use only.
+ */
+export declare function registerFilteringListener(filterExpression: string): void;
+/**
+ * @internal
+ * This method is for internal use only.
+ */
+export declare function registerFilteringAndObfuscationListener(filterExpression: string): void;
+/**
+ * @internal
+ * This method is for internal use only.
+ */
+export declare function checkNetworkRequestHandlers(): void;
+export declare function resetNativeObfuscationListener(): void;
+/**
+ * @internal
+ * This method is for internal use only.
+ */
+export declare function updateNetworkLogSnapshot(networkSnapshot: NetworkData): void;
+declare const _default: {
+    parseErrorStack: (error: ExtendedError) => StackFrame[];
+    captureJsErrors: () => void;
+    getActiveRouteName: (navigationState: NavigationStateV4) => string | null;
+    getFullRoute: typeof getFullRoute;
+    getStackTrace: (e: ExtendedError) => StackFrame[];
+    stringifyIfNotString: (input: unknown) => string;
+    sendCrashReport: typeof sendCrashReport;
+    reportNetworkLog: (network: NetworkData) => void;
+    generateTracePartialId: () => {
+        numberPartilId: number;
+        hexStringPartialId: string;
+    };
+    generateW3CHeader: (networkStartTime: number) => {
+        timestampInSeconds: number;
+        partialId: number;
+        w3cHeader: string;
+    };
+};
+export default _default;

package/dist/utils/LuciqUtils.js

@@ -0,0 +1,301 @@
+import { Platform } from 'react-native';
+import parseErrorStackLib from 'react-native/Libraries/Core/Devtools/parseErrorStack';
+import { NativeCrashReporting } from '../native/NativeCrashReporting';
+import { NativeLuciq } from '../native/NativeLuciq';
+import { NativeAPM } from '../native/NativeAPM';
+import * as NetworkLogger from '../modules/NetworkLogger';
+import { NativeNetworkLogger, NativeNetworkLoggerEvent, NetworkListenerType, NetworkLoggerEmitter, } from '../native/NativeNetworkLogger';
+let apmFlags = {
+    isNativeInterceptionFeatureEnabled: false,
+    hasAPMNetworkPlugin: false,
+    shouldEnableNativeInterception: false,
+};
+export function setApmNetworkFlagsIfChanged(flags) {
+    if (flags.hasAPMNetworkPlugin === apmFlags.hasAPMNetworkPlugin &&
+        flags.isNativeInterceptionFeatureEnabled === apmFlags.isNativeInterceptionFeatureEnabled &&
+        flags.shouldEnableNativeInterception === apmFlags.shouldEnableNativeInterception) {
+        return false;
+    }
+    apmFlags = flags;
+    return true;
+}
+export const parseErrorStack = (error) => {
+    return parseErrorStackLib(error);
+};
+export const getCrashDataFromError = (error) => {
+    const jsStackTrace = getStackTrace(error);
+    const jsonObject = {
+        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) => {
+    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) {
+    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) => {
+    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, _isFatal) => {
+        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) => {
+    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, remoteSenderCallback) {
+    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;
+    let hexString;
+    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) => {
+    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) {
+    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) => {
+    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) {
+    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) {
+    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) {
+    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/dist/utils/UnhandledRejectionTracking.d.ts

@@ -0,0 +1,9 @@
+import { RejectionTrackingOptions } from 'promise/setimmediate/rejection-tracking';
+export interface HermesInternalType {
+    enablePromiseRejectionTracker?: (options?: RejectionTrackingOptions) => void;
+    hasPromise?: () => boolean;
+}
+/**
+ * Tracks whether an unhandled Promise rejection happens and reports it.
+ */
+export declare function captureUnhandledRejections(): void;

package/dist/utils/UnhandledRejectionTracking.js

@@ -0,0 +1,99 @@
+import tracking from 'promise/setimmediate/rejection-tracking';
+import { sendCrashReport } from './LuciqUtils';
+import { NativeCrashReporting } from '../native/NativeCrashReporting';
+import { NonFatalErrorLevel } from './Enums';
+import { Logger } from './logger';
+/**
+ * A typed version of the `HermesInternal` global object with the properties
+ * we use.
+ */
+function _getHermes() {
+    return global.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) {
+    const hermes = _getHermes();
+    hermes.enablePromiseRejectionTracker(options);
+}
+/**
+ * Enables unhandled Promise rejection tracking in the default `promise` polyfill.
+ *
+ * @param options Rejection tracking options.
+ */
+function _enableDefaultRejectionTracking(options) {
+    tracking.enable(options);
+}
+/**
+ * Tracks whether an unhandled Promise rejection happens and reports it.
+ */
+export function captureUnhandledRejections() {
+    const options = {
+        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, rejection) {
+    _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, rejection = {}) {
+    let message;
+    let stack;
+    const stringValue = Object.prototype.toString.call(rejection);
+    if (stringValue === '[object Error]') {
+        message = Error.prototype.toString.call(rejection);
+        const error = rejection;
+        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);
+}

package/dist/utils/XhrNetworkInterceptor.d.ts

@@ -0,0 +1,39 @@
+export type ProgressCallback = (totalBytesSent: number, totalBytesExpectedToSend: number) => void;
+export type NetworkDataCallback = (data: NetworkData) => void;
+export interface NetworkData {
+    readonly id: string;
+    url: string;
+    method: string;
+    requestBody: string;
+    requestBodySize: number;
+    responseBody: string | null;
+    responseBodySize: number;
+    responseCode: number;
+    requestHeaders: Record<string, string>;
+    responseHeaders: Record<string, string>;
+    contentType: string;
+    errorDomain: string;
+    errorCode: number;
+    startTime: number;
+    duration: number;
+    gqlQueryName?: string;
+    serverErrorMessage: string;
+    requestContentType: string;
+    isW3cHeaderFound: boolean | null;
+    partialId: number | null;
+    networkStartTimeInSeconds: number | null;
+    w3cGeneratedHeader: string | null;
+    w3cCaughtHeader: string | null;
+}
+export declare const injectHeaders: (networkData: NetworkData, featureFlags: {
+    isW3cExternalTraceIDEnabled: boolean;
+    isW3cExternalGeneratedHeaderEnabled: boolean;
+    isW3cCaughtHeaderEnabled: boolean;
+}) => string | undefined;
+declare const _default: {
+    setOnDoneCallback(callback: NetworkDataCallback): void;
+    setOnProgressCallback(callback: ProgressCallback): void;
+    enableInterception(): void;
+    disableInterception(): void;
+};
+export default _default;