@openreplay/tracker 11.0.6 → 12.0.0-beta.99

package/CHANGELOG.md

@@ -1,6 +1,8 @@
-# 11.0.6
+# 12.0.0
 
-- fix blob generation for canvas capture (Cannot read properties of null (reading '1'))
+- offline session recording and manual sending
+- conditional recording with 30s buffer
+- websockets tracking hook
 
 # 11.0.5
 

package/cjs/app/index.d.ts

@@ -1,17 +1,17 @@
-import type Message from './messages.gen.js';
+import FeatureFlags from '../modules/featureFlags.js';
+import Message from './messages.gen.js';
 import Nodes from './nodes.js';
 import Observer from './observer/top_observer.js';
 import Sanitizer from './sanitizer.js';
 import Ticker from './ticker.js';
-import Logger from './logger.js';
+import Logger, { ILogLevel } from './logger.js';
 import Session from './session.js';
 import AttributeSender from '../modules/attributeSender.js';
 import type { Options as ObserverOptions } from './observer/top_observer.js';
 import type { Options as SanitizerOptions } from './sanitizer.js';
-import type { Options as LoggerOptions } from './logger.js';
 import type { Options as SessOptions } from './session.js';
 import type { Options as NetworkOptions } from '../modules/network.js';
-import type { Options as WebworkerOptions } from '../common/interaction.js';
+import type { Options as WebworkerOptions, FromWorkerData } from '../common/interaction.js';
 export interface StartOptions {
     userID?: string;
     metadata?: Record<string, string>;
@@ -46,22 +46,23 @@ type AppOptions = {
     local_uuid_key: string;
     ingestPoint: string;
     resourceBaseHref: string | null;
-    verbose: boolean;
     __is_snippet: boolean;
     __debug_report_edp: string | null;
-    __debug__?: LoggerOptions;
+    __debug__?: ILogLevel;
     __save_canvas_locally?: boolean;
     localStorage: Storage | null;
     sessionStorage: Storage | null;
     forceSingleTab?: boolean;
     disableStringDict?: boolean;
     assistSocketHost?: string;
+    /** @deprecated */
     onStart?: StartCallback;
     network?: NetworkOptions;
 } & WebworkerOptions & SessOptions;
 export type Options = AppOptions & ObserverOptions & SanitizerOptions;
 export declare const DEFAULT_INGEST_POINT = "https://api.openreplay.com/ingest";
 export default class App {
+    private readonly signalError;
     readonly nodes: Nodes;
     readonly ticker: Ticker;
     readonly projectKey: string;
@@ -72,6 +73,12 @@ export default class App {
     readonly localStorage: Storage;
     readonly sessionStorage: Storage;
     private readonly messages;
+    /**
+     * we need 2 buffers, so we don't lose anything
+     * @read coldStart implementation
+     * */
+    private bufferedMessages1;
+    private readonly bufferedMessages2;
     readonly observer: Observer;
     private readonly startCallbacks;
     private readonly stopCallbacks;
@@ -81,7 +88,7 @@ export default class App {
     private readonly revID;
     private activityState;
     private readonly version;
-    private readonly worker?;
+    private readonly workerManager?;
     private compressionThreshold;
     private restartAttempts;
     private readonly bc;
@@ -89,11 +96,29 @@ export default class App {
     attributeSender: AttributeSender;
     private canvasRecorder;
     private uxtManager;
-    constructor(projectKey: string, sessionToken: string | undefined, options: Partial<Options>);
-    private _debug;
+    private conditionsManager;
+    featureFlags: FeatureFlags;
+    private readonly tagWatcher;
+    constructor(projectKey: string, sessionToken: string | undefined, options: Partial<Options>, signalError: (error: string, apis: string[]) => void);
+    handleWorkerMsg(data: FromWorkerData): void;
+    private readonly _debug;
     private _usingOldFetchPlugin;
     send(message: Message, urgent?: boolean): void;
+    /**
+     * Normal workflow: add timestamp and tab data to batch, then commit it
+     * every ~30ms
+     * */
+    private _nCommit;
+    coldStartCommitN: number;
+    /**
+     * Cold start: add timestamp and tab data to both batches
+     * every 2nd tick, ~60ms
+     * this will make batches a bit larger and replay will work with bigger jumps every frame
+     * but in turn we don't overload batch writer on session start with 1000 batches
+     * */
+    private _cStartCommit;
     private commit;
+    private postToWorker;
     private delay;
     timestamp(): number;
     safe<T extends (this: any, ...args: any[]) => void>(fn: T): T;
@@ -127,8 +152,55 @@ export default class App {
     isServiceURL(url: string): boolean;
     active(): boolean;
     resetNextPageSession(flag: boolean): void;
+    coldInterval: ReturnType<typeof setInterval> | null;
+    orderNumber: number;
+    coldStartTs: number;
+    singleBuffer: boolean;
+    private checkSessionToken;
+    /**
+     * start buffering messages without starting the actual session, which gives
+     * user 30 seconds to "activate" and record session by calling `start()` on conditional trigger,
+     * and we will then send buffered batch, so it won't get lost
+     * */
+    coldStart(startOpts?: StartOptions, conditional?: boolean): Promise<void>;
+    onSessionSent: () => void;
+    /**
+     * Starts offline session recording
+     * @param {Object} startOpts - options for session start, same as .start()
+     * @param {Function} onSessionSent - callback that will be called once session is fully sent
+     * */
+    offlineRecording(startOpts: StartOptions | undefined, onSessionSent: () => void): {
+        saveBuffer: () => void;
+        getBuffer: () => Message[];
+        setBuffer: (buffer: Message[]) => void;
+    };
+    /**
+     * Saves the captured messages in localStorage (or whatever is used in its place)
+     *
+     * Then, when this.offlineRecording is called, it will preload this messages and clear the storage item
+     *
+     * Keeping the size of local storage reasonable is up to the end users of this library
+     * */
+    saveBuffer(): void;
+    /**
+     * @returns buffer with stored messages for offline recording
+     * */
+    getBuffer(): Message[];
+    /**
+     * Used to set a buffer with messages array
+     * */
+    setBuffer(buffer: Message[]): void;
+    /**
+     * Uploads the stored session buffer to backend
+     * @returns promise that resolves once messages are loaded, it has to be awaited
+     * so the session can be uploaded properly
+     * @resolve - if messages were loaded in service worker successfully
+     * @reject {string} - error message
+     * */
+    uploadOfflineRecording(): Promise<void>;
     private _start;
     restartCanvasTracking: () => void;
+    flushBuffer: (buffer: Message[]) => Promise<unknown>;
     onUxtCb: never[];
     addOnUxtCb(cb: (id: number) => void): void;
     getUxtId(): number | null;
@@ -139,6 +211,13 @@ export default class App {
     start(...args: Parameters<App['_start']>): Promise<StartPromiseReturn>;
     forceFlushBatch(): void;
     getTabId(): string;
+    clearBuffers(): void;
+    /**
+     * Creates a named hook that expects event name, data string and msg direction (up/down),
+     * it will skip any message bigger than 5 mb or event name bigger than 255 symbols
+     * @returns {(msgType: string, data: string, dir: "up" | "down") => void}
+     * */
+    trackWs(channelName: string): (msgType: string, data: string, dir: 'up' | 'down') => void;
     stop(stopWorker?: boolean): void;
 }
 export {};