noibu-react-native 0.1.2 → 0.2.0

package/dist/monitors/keyboardInputMonitor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * KeyboardInputMonitor is a listener class that attaches a
+ * keyboard input listener of the document object.
+ */
+export class KeyboardInputMonitor {
+    /**
+     * Begins the monitoring process
+     * we currently only monitor two input locations: textarea and input
+     */
+    monitor(): void;
+    /**
+     * Validates an event
+     * @param uiViewClassName
+     * @param props
+     */
+    _handle(uiViewClassName: any, props: any): void;
+}

package/dist/monitors/pageMonitor.d.ts

@@ -0,0 +1,22 @@
+/** Monitors the page events which we capture and later process */
+export class PageMonitor {
+    /**
+     * gets the singleton instance
+     * @returns {PageMonitor}
+     */
+    static getInstance(): PageMonitor;
+    /** Starts monitoring page events on the document */
+    monitor(): void;
+    /**
+     * Handles a single page event
+     * @param  {} event
+     */
+    _onPageEventHandle(event: any): void;
+    /** Returns document state */
+    getDocumentState(): "hidden" | "active" | "passive";
+    /**
+     * Returns object size in bytes
+     * @param  {} obj
+     */
+    getSizeInBytes(obj: any): number;
+}

package/dist/monitors/requestMonitor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Handles fetch failure
+ * @param  {} err
+ * @param  {} url
+ */
+export function handleFetchFailure(err: any, url: any): void;
+/**
+ * Monitors all requests
+ */
+export function monitorRequests(): void;

package/dist/pageVisit/pageVisit.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Singleton class to hold all the information
+ * about the gathered errors throught the session
+ */
+export class PageVisit {
+    /**
+     * creates a PV object
+     */
+    static configureInstance(): void;
+    /** gets the singleton instance
+     * @returns {PageVisit}
+     */
+    static getInstance(): PageVisit;
+    /**
+     * Creates a page visit frag from an events array and part counter. Appends
+     * the end time field and returns the frag
+     * @param  {} pvEvents
+     * @param  {} partCounter
+     */
+    static makePageVisitFrag(pvEvents: any, partCounter: any): any;
+    partCounter: number;
+    pvMap: {};
+    pvEventLength: number;
+    visibilityChangedCounter: number;
+    totalPvEventLength: number;
+    inDebounceHandle: number;
+    isInAcceleratedPvPostMode: boolean;
+    /** adds page visit events into the current page visit map and then sends a page visit message
+     * @param  {} eventObjects
+     * @param  {} type
+     */
+    addPageVisitEvents(eventObjects: any, type: any): void;
+    /**
+     * adds the page visit event into the current page visit map and then sends a page visit message
+     * returns the the key to access this event in the map
+     * @param  {} eventObj
+     * @param  {} type
+     */
+    addPageVisitEvent(eventObj: any, type: any): string | number[];
+    /**
+     * adds a new page visit event into the current page visit map and returns the
+     * the key to access this event in the map
+     * @param  {} eventObj
+     * @param  {} type
+     */
+    _addPageVisitEvent(eventObj: any, type: any): string | number[];
+    /**
+     * _sendPageVisitMessage will reset the buffer and post the current
+     * content to metroplex
+     */
+    _sendPageVisitMessage(): void;
+}

package/dist/pageVisit/pageVisit.js

@@ -3,6 +3,7 @@ import { TYPE_ATT_NAME, OCCURRED_AT_ATT_NAME, MAX_PAGEVISIT_EVENTS, MAX_PAGEVISI
 import ClientConfig from '../api/clientConfig.js';
 import MetroplexSocket from '../api/metroplexSocket.js';
 import StoredMetrics from '../api/storedMetrics.js';
+import { noibuLog } from '../utils/log.js';
 
 /** @module Pagevisit */
 
@@ -64,6 +65,10 @@ class PageVisit {
    * @param  {} type
    */
   addPageVisitEvent(eventObj, type) {
+    noibuLog('addPageVisitEvent', {
+      eventObj,
+      type,
+    });
     const id = this._addPageVisitEvent(eventObj, type);
     this._sendPageVisitMessage();
     return id;
@@ -112,8 +117,10 @@ class PageVisit {
     const pagevistFrag = {};
     pagevistFrag[PV_EVENTS_ATT_NAME] = pvEvents;
     pagevistFrag[PV_PART_COUNTER_ATT_NAME] = partCounter;
-    MetroplexSocket.getInstance().addEndTimeToPayload(pagevistFrag, true);
-    return pagevistFrag;
+    return MetroplexSocket.getInstance().addEndTimeToPayload(
+      pagevistFrag,
+      true,
+    );
   }
 
   /**

package/dist/pageVisit/pageVisitEventError.d.ts

@@ -0,0 +1,15 @@
+/**
+ * gets the onURL of a string, defaulting to the location of the webpage
+ */
+export function getOnURL(realOnURL: any): string;
+/**
+ * determines if an error is a collect error
+ * @param  {} pvError
+ */
+export function isErrorCollectedByNoibu(pvError: any): boolean;
+/** Saves the error to the ErrorQueue
+ * @param  {} type
+ * @param  {} payload
+ * @param  {} [httpDataSeqNum]
+ */
+export function saveErrorToPagevisit(type: any, payload: any, httpDataSeqNum?: any): void;

package/dist/pageVisit/pageVisitEventHTTP.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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/pageVisit/userStep.d.ts

@@ -0,0 +1,5 @@
+/**
+ * updates the payload of a user step in order to stringify the css class
+ * @param  {} payload
+ */
+export function updatePayload(payload: any): any;

package/dist/react/ErrorBoundary.js

@@ -36,7 +36,9 @@ class ErrorBoundary extends React.Component {
         InputManager.getInstance()._addErrorFromJSSdk(error, 'ReactError');
         const eventId = uuid.v4();
         if (onError) {
-            onError(error, componentStack, eventId);
+            if (typeof componentStack === 'string') {
+                onError(error, componentStack, eventId);
+            }
         }
         // componentDidCatch is used over getDerivedStateFromError
         // so that componentStack is accessible through state.
@@ -50,7 +52,9 @@ class ErrorBoundary extends React.Component {
         const { error, componentStack, eventId } = this.state;
         const { onUnmount } = this.props;
         if (onUnmount) {
-            onUnmount(error, componentStack, eventId);
+            if (typeof componentStack === 'string') {
+                onUnmount(error, componentStack, eventId);
+            }
         }
     }
     /**
@@ -61,7 +65,9 @@ class ErrorBoundary extends React.Component {
         const { onReset } = this.props;
         const { error, componentStack, eventId } = this.state;
         if (onReset) {
-            onReset(error, componentStack, eventId);
+            if (typeof componentStack === 'string') {
+                onReset(error, componentStack, eventId);
+            }
         }
         this.setState(INITIAL_STATE);
     };
@@ -76,12 +82,14 @@ class ErrorBoundary extends React.Component {
         if (error) {
             let element;
             if (typeof fallback === 'function') {
-                element = fallback({
-                    error,
-                    componentStack,
-                    resetError: this.resetErrorBoundary.bind(this),
-                    eventId,
-                });
+                if (typeof componentStack === 'string') {
+                    element = fallback({
+                        error,
+                        componentStack,
+                        resetError: this.resetErrorBoundary.bind(this),
+                        eventId,
+                    });
+                }
             }
             else {
                 element = fallback;

package/dist/sessionRecorder/nativeSessionRecorderSubscription.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The level of logging to show in the device logcat stream.
+ */
+export declare enum LogLevel {
+    Verbose = "Verbose",
+    Debug = "Debug",
+    Info = "Info",
+    Warning = "Warning",
+    Error = "Error",
+    None = "None"
+}
+/**
+ * The configuration that will be used to customize the session recording behaviour.
+ *
+ * @param userId        [OPTIONAL default = null] A custom identifier for the current user. If passed as null, the user id
+ *                      will be auto generated. The user id in general is sticky across sessions.
+ *                      The provided user id must follow these conditions:
+ *                          1. Cannot be an empty string.
+ *                          2. Should be base36 and smaller than "1Z141Z4".
+ * @param logLevel      [OPTIONAL default = LogLevel.None] The level of logging to show in the device logcat stream.
+ * @param allowMeteredNetworkUsage  [OPTIONAL default = false] Allows uploading session data to the servers on device metered network.
+ * @param enableWebViewCapture    [OPTIONAL default = true] Allows Noibu - Session recorder to capture the web views DOM content.
+ * @param allowedDomains    [OPTIONAL default = ["*"]] The whitelisted domains to allow Noibu - Session recorder to capture their DOM content.
+ *                          If it contains "*" as an element, all domains will be captured.
+ * @param disableOnLowEndDevices [OPTIONAL default = false] Disable Noibu - Session recorder on low-end devices.
+ * @param maximumDailyNetworkUsageInMB [OPTIONAL default = null] Maximum daily network usage for Noibu - Session recorder (null = No limit). When the limit is reached, Noibu - Session recorder will turn on lean mode.
+ */
+export interface SessionRecorderConfig {
+    userId?: string | null;
+    logLevel?: LogLevel;
+    allowMeteredNetworkUsage?: boolean;
+    enableWebViewCapture?: boolean;
+    allowedDomains?: string[];
+    disableOnLowEndDevices?: boolean;
+    maximumDailyNetworkUsageInMB?: number;
+}
+/**
+ * Initializes the Noibu - Session recording SDK if the API level is supported.
+ * param projectId     [REQUIRED] The session recording project id to send data to.
+ * param config   [OPTIONAL] The sessionreplay config, if not provided default values are used.
+ */
+export declare function initialize(projectId: string, config?: SessionRecorderConfig): void;
+/**
+ * Sets a custom user id that can be used to identify the user. It has less
+ * restrictions than the userId parameter. You can pass any string and
+ * you can filter on it on the dashboard side. If you need the most efficient
+ * filtering on the dashboard, use the userId parameter if possible.
+ * <p>
+ * Note: custom user id cannot be null or empty, or consists only of whitespaces.
+ * </p>
+ * @param customUserId   The custom user id to set.
+ */
+export declare function setCustomUserId(customUserId: string): void;
+/**
+ * Sets a custom session id that can be used to identify the session.
+ * <p>
+ * Note: custom session id cannot be null or empty, or consists only of whitespaces.
+ * </p>
+ * @param customSessionId   The custom session id to set.
+ */
+export declare function setCustomSessionId(customSessionId: string): void;
+export type RecorderEvent = import('./types').RecorderEvent;
+export type UnsubscribeFn = import('./types').UnsubscribeFn;
+export declare function subscribeToNativeEvent(callback: (event: RecorderEvent) => void): UnsubscribeFn;

package/dist/sessionRecorder/nativeSessionRecorderSubscription.js

@@ -0,0 +1,58 @@
+import { NativeEventEmitter, Platform, NativeModules } from 'react-native';
+import { noibuLog } from '../utils/log.js';
+
+const LINKING_ERROR = `The package 'noibu-session-replay' doesn't seem to be linked. Make sure: \n\n` +
+    // Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) + TODO: add back when iOS is supported.
+    '- You rebuilt the app after installing the package\n' +
+    '- You are not using Expo Go\n';
+const { NativeSessionRecorder } = NativeModules;
+let nativeModuleEmitter;
+const SupportedPlatforms = ['android'];
+/**
+ * The level of logging to show in the device logcat stream.
+ */
+// eslint-disable-next-line no-shadow
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Verbose"] = "Verbose";
+    LogLevel["Debug"] = "Debug";
+    LogLevel["Info"] = "Info";
+    LogLevel["Warning"] = "Warning";
+    LogLevel["Error"] = "Error";
+    LogLevel["None"] = "None";
+})(LogLevel || (LogLevel = {}));
+/**
+ * Initializes the Noibu - Session recording SDK if the API level is supported.
+ * param projectId     [REQUIRED] The session recording project id to send data to.
+ * param config   [OPTIONAL] The sessionreplay config, if not provided default values are used.
+ */
+function initialize(projectId, config) {
+    if (!(typeof config === 'object' || typeof config === 'undefined')) {
+        throw Error('Invalid session recording initialization arguments. Please check the docs for assitance.');
+    }
+    nativeModuleEmitter = new NativeEventEmitter(NativeSessionRecorder);
+    // applying default values
+    const { userId = null, logLevel = LogLevel.None, allowMeteredNetworkUsage = false, enableWebViewCapture = true, allowedDomains = ['*'], disableOnLowEndDevices = false, maximumDailyNetworkUsageInMB = null, } = config ?? {};
+    if (!SupportedPlatforms.includes(Platform.OS)) {
+        noibuLog(`Noibu - Session recording supports ${SupportedPlatforms.join(', ')} only for now.`);
+        return;
+    }
+    if (NativeSessionRecorder === null) {
+        noibuLog('Noibu - Session recording did not initialize properly.', LINKING_ERROR);
+        return;
+    }
+    // We use two parameters because the react method parameters do not accept nullable primitive types.
+    const enableDailyNetworkUsageLimit = maximumDailyNetworkUsageInMB != null;
+    const refinedMaximumDailyNetworkUsageInMB = maximumDailyNetworkUsageInMB ?? 0;
+    NativeSessionRecorder.initialize(projectId, userId, logLevel, allowMeteredNetworkUsage, enableWebViewCapture, allowedDomains, disableOnLowEndDevices, enableDailyNetworkUsageLimit, refinedMaximumDailyNetworkUsageInMB);
+}
+function subscribeToNativeEvent(callback) {
+    if (!nativeModuleEmitter) {
+        throw new Error('You have to initialize Noibu Session Recorder first');
+    }
+    nativeModuleEmitter.addListener('noibuRecordingEvent', callback);
+    // return () => subscription.remove();
+    return () => { };
+}
+
+export { LogLevel, initialize, subscribeToNativeEvent };

package/dist/sessionRecorder/sessionRecorder.d.ts

@@ -0,0 +1,60 @@
+import { RecorderEvent } from './nativeSessionRecorderSubscription';
+/** Singleton class to record user sessions */
+export default class SessionRecorder {
+    private static instance;
+    private eventBuffer;
+    private vfCounter;
+    private didSetupRecorder;
+    private isVideoLengthNegativeInvalid;
+    private lastFragPostTimestamp;
+    private pauseTimeout;
+    private lastRecordedTimestamp;
+    private firstRecordedTimestamp;
+    private recordStopper;
+    private freezingEvents;
+    /**
+     * Creates an instance of the session recorder
+     */
+    constructor();
+    /**
+     * Setups the SessionRecorder instance for usage
+     */
+    static getInstance(): SessionRecorder;
+    /** Sets up the page hide handler to try to push remaining video events */
+    setupUnloadHandler(): void;
+    /** Sets up the post metrics handler to potentially log a debug message */
+    setupPostMetricsHandler(): void;
+    /**
+     * Starts recording the user session
+     */
+    recordUserSession(): Promise<void>;
+    /**
+     * handleNewRRwebEvent will process each upcoming.
+     * rrweb event. It will make sure that the current buffer
+     * is updated with the latest events and post the contents
+     * of the buffer if it exceeds max size
+     */
+    handleRecorderEvent(recorderEvent: RecorderEvent): Promise<void>;
+    /**
+     * Compress event
+     */
+    private pack;
+    private static compress;
+    /** builds a log message with debug info
+     */
+    buildDebugMessage(eventName: string, totalVideoTime: number, sessionLength: number): string;
+    /**
+     * handleFragPost communicates with the Metroplex socket
+     * to post video fragments when needed. It also handles
+     * necessary management of the buffer and it's related
+     * variables
+     */
+    handleFragPost(): Promise<void>;
+    /**
+     * unfreeze forcefully resumes recording events in case it was frozen
+     * waiting for user events
+     */
+    unfreeze(): Promise<void>;
+    /** stops recording */
+    private freeze;
+}