@openreplay/tracker 12.0.11 → 12.1.0-beta.99

package/cjs/app/workerManager/index.d.ts

@@ -0,0 +1,37 @@
+import { FromWorkerData, ToWorkerData, WorkerAuth, WorkerStart } from '../../common/interaction.js';
+import App from '../index.js';
+import QueueSender from './QueueSender.js';
+declare enum WorkerStatus {
+    NotActive = 0,
+    Starting = 1,
+    Stopping = 2,
+    Active = 3,
+    Stopped = 4
+}
+interface TypedWorker extends Omit<Worker, 'postMessage'> {
+    postMessage(data: ToWorkerData): void;
+}
+declare class WebWorkerManager {
+    private readonly app;
+    private readonly worker;
+    private readonly onError;
+    sendIntervalID: ReturnType<typeof setInterval> | null;
+    restartTimeoutID: ReturnType<typeof setTimeout> | null;
+    workerStatus: WorkerStatus;
+    sender: QueueSender | null;
+    constructor(app: App, worker: TypedWorker, onError: (ctx: string, e: any) => any);
+    finalize: () => void;
+    resetWebWorker: () => void;
+    resetSender: () => void;
+    reset: () => void;
+    initiateRestart: () => void;
+    initiateFailure: (reason: string) => void;
+    processMessage: (data: ToWorkerData | null) => void;
+    startWorker: (data: WorkerStart) => void;
+    stopWorker: () => void;
+    authorizeWorker: (data: WorkerAuth) => void;
+    sendCompressedBatch: (data: Uint8Array) => void;
+    sendUncompressedBatch: (data: Uint8Array) => void;
+    postMessage: (data: FromWorkerData) => void;
+}
+export default WebWorkerManager;

package/cjs/app/workerManager/index.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const QueueSender_js_1 = __importDefault(require("./QueueSender.js"));
+var WorkerStatus;
+(function (WorkerStatus) {
+    WorkerStatus[WorkerStatus["NotActive"] = 0] = "NotActive";
+    WorkerStatus[WorkerStatus["Starting"] = 1] = "Starting";
+    WorkerStatus[WorkerStatus["Stopping"] = 2] = "Stopping";
+    WorkerStatus[WorkerStatus["Active"] = 3] = "Active";
+    WorkerStatus[WorkerStatus["Stopped"] = 4] = "Stopped";
+})(WorkerStatus || (WorkerStatus = {}));
+const AUTO_SEND_INTERVAL = 10 * 1000;
+const rebroadcastEvents = ['queue_empty', 'not_init', 'restart'];
+class WebWorkerManager {
+    constructor(app, worker, onError) {
+        this.app = app;
+        this.worker = worker;
+        this.onError = onError;
+        this.sendIntervalID = null;
+        this.restartTimeoutID = null;
+        this.workerStatus = WorkerStatus.NotActive;
+        this.sender = null;
+        this.finalize = () => {
+            this.worker.postMessage({ type: 'writer_finalize' });
+        };
+        this.resetWebWorker = () => {
+            this.worker.postMessage({ type: 'reset_writer' });
+        };
+        this.resetSender = () => {
+            if (!this.sender) {
+                return;
+            }
+            this.sender.clean();
+            setTimeout(() => {
+                this.sender = null;
+            }, 20);
+        };
+        this.reset = () => {
+            this.workerStatus = WorkerStatus.Stopping;
+            if (this.sendIntervalID !== null) {
+                clearInterval(this.sendIntervalID);
+                this.sendIntervalID = null;
+            }
+            this.resetSender();
+            this.resetWebWorker();
+            setTimeout(() => {
+                this.workerStatus = WorkerStatus.NotActive;
+            }, 100);
+        };
+        this.initiateRestart = () => {
+            if (this.workerStatus === WorkerStatus.Stopped) {
+                return;
+            }
+            this.postMessage({ type: 'restart' });
+            this.reset();
+        };
+        this.initiateFailure = (reason) => {
+            if ([WorkerStatus.Stopped, WorkerStatus.Stopping, WorkerStatus.NotActive].includes(this.workerStatus)) {
+                return;
+            }
+            this.postMessage({ type: 'failure', reason });
+            this.reset();
+        };
+        this.processMessage = (data) => {
+            if (data === null) {
+                this.finalize();
+                return;
+            }
+            if (data.type === 'batch' && Array.isArray(data.data)) {
+                data.data.forEach((message) => {
+                    if (message[0] === 55 /* MType.SetPageVisibility */) {
+                        // document is hidden
+                        if (message[1]) {
+                            this.restartTimeoutID = setTimeout(() => this.initiateRestart(), 30 * 60 * 1000);
+                        }
+                        else {
+                            if (this.restartTimeoutID) {
+                                clearTimeout(this.restartTimeoutID);
+                            }
+                        }
+                    }
+                });
+                this.worker.postMessage({ type: 'to_writer', data: data.data });
+            }
+        };
+        this.startWorker = (data) => {
+            this.sender = new QueueSender_js_1.default(data.ingestPoint, () => {
+                // onUnauthorised
+                this.initiateRestart();
+            }, (reason) => {
+                // onFailure
+                this.initiateFailure(reason);
+            }, data.connAttemptCount, data.connAttemptGap, (batch) => {
+                this.postMessage({ type: 'compress', batch });
+            });
+            if (this.sendIntervalID === null) {
+                this.sendIntervalID = setInterval(this.finalize, AUTO_SEND_INTERVAL);
+            }
+            this.worker.postMessage(data);
+            return;
+        };
+        this.stopWorker = () => {
+            this.finalize();
+            this.reset();
+            return;
+        };
+        this.authorizeWorker = (data) => {
+            if (!this.sender) {
+                console.debug('OR WebWorker: sender not initialised. Received auth.');
+                this.initiateRestart();
+                return;
+            }
+            this.sender.authorise(data.token);
+            if (data.beaconSizeLimit) {
+                this.worker.postMessage({ type: 'beacon_size_limit', data: data.beaconSizeLimit });
+            }
+            return;
+        };
+        this.sendCompressedBatch = (data) => {
+            if (!this.sender) {
+                console.debug('OR Worker: sender not init. Compressed batch');
+                this.initiateRestart();
+                return;
+            }
+            this.sender?.sendCompressed(data);
+            return;
+        };
+        this.sendUncompressedBatch = (data) => {
+            if (!this.sender) {
+                console.debug('OR Worker: sender not init. Compressed batch.');
+                this.initiateRestart();
+                return;
+            }
+            if (data) {
+                this.sender.sendUncompressed(data);
+                return;
+            }
+        };
+        this.postMessage = (data) => {
+            this.app.handleWorkerMsg(data);
+        };
+        this.worker.onerror = (e) => {
+            this.onError('webworker_error', e);
+        };
+        this.worker.onmessage = ({ data }) => {
+            if (rebroadcastEvents.includes(data.type)) {
+                this.postMessage(data);
+                return;
+            }
+            switch (data.type) {
+                case 'status':
+                    this.workerStatus = data.data;
+                    return;
+                case 'batch_ready':
+                    if (this.sender) {
+                        this.app.debug.log('Openreplay: msg batch to sender: ', data.data);
+                        this.sender.push(data.data);
+                    }
+            }
+        };
+    }
+}
+exports.default = WebWorkerManager;

package/cjs/common/interaction.d.ts

@@ -3,7 +3,61 @@ export interface Options {
     connAttemptCount?: number;
     connAttemptGap?: number;
 }
-type Start = {
+export type ToWorkerData = null | Stop | Batch | WorkerStart | BeaconSizeLimit | ToWriterData | ForceFlushBatch | CheckQueue | ResetWriter | WriterFinalize;
+export type FromWorkerData = Restart | Failure | NotInit | Compress | QEmpty | Status | BatchReady;
+type BatchReady = {
+    type: 'batch_ready';
+    data: Uint8Array;
+};
+type Status = {
+    type: 'status';
+    data: number;
+};
+type Compress = {
+    type: 'compress';
+    batch: Uint8Array;
+};
+type Restart = {
+    type: 'restart';
+};
+type NotInit = {
+    type: 'not_init';
+};
+type Stop = {
+    type: 'stop';
+};
+type Batch = {
+    type: 'batch';
+    data: Array<Message>;
+};
+type ForceFlushBatch = {
+    type: 'forceFlushBatch';
+};
+type CheckQueue = {
+    type: 'check_queue';
+};
+type WriterFinalize = {
+    type: 'writer_finalize';
+};
+type ResetWriter = {
+    type: 'reset_writer';
+};
+type BeaconSizeLimit = {
+    type: 'beacon_size_limit';
+    data: number;
+};
+type ToWriterData = {
+    type: 'to_writer';
+    data: Array<Message>;
+};
+type Failure = {
+    type: 'failure';
+    reason: string;
+};
+type QEmpty = {
+    type: 'queue_empty';
+};
+export type WorkerStart = {
     type: 'start';
     ingestPoint: string;
     pageNo: number;
@@ -11,27 +65,8 @@ type Start = {
     url: string;
     tabId: string;
 } & Options;
-type Auth = {
-    type: 'auth';
+export type WorkerAuth = {
     token: string;
     beaconSizeLimit?: number;
 };
-export type ToWorkerData = null | 'stop' | Start | Auth | Array<Message> | {
-    type: 'compressed';
-    batch: Uint8Array;
-} | {
-    type: 'uncompressed';
-    batch: Uint8Array;
-} | 'forceFlushBatch' | 'check_queue';
-type Failure = {
-    type: 'failure';
-    reason: string;
-};
-type QEmpty = {
-    type: 'queue_empty';
-};
-export type FromWorkerData = 'a_stop' | 'a_start' | Failure | 'not_init' | {
-    type: 'compress';
-    batch: Uint8Array;
-} | QEmpty;
 export {};

package/cjs/common/messages.gen.d.ts

@@ -30,7 +30,7 @@ export declare const enum Type {
     Profiler = 40,
     OTable = 41,
     StateAction = 42,
-    ReduxDeprecated = 44,
+    Redux = 44,
     Vuex = 45,
     MobX = 46,
     NgRx = 47,
@@ -71,7 +71,7 @@ export declare const enum Type {
     TabData = 118,
     CanvasNode = 119,
     TagTrigger = 120,
-    Redux = 121
+    ReduxNew = 121
 }
 export type Timestamp = [
     Type.Timestamp,
@@ -252,8 +252,8 @@ export type StateAction = [
     Type.StateAction,
     string
 ];
-export type ReduxDeprecated = [
-    Type.ReduxDeprecated,
+export type Redux = [
+    Type.Redux,
     string,
     string,
     number
@@ -509,12 +509,12 @@ export type TagTrigger = [
     Type.TagTrigger,
     number
 ];
-export type Redux = [
-    Type.Redux,
+export type ReduxNew = [
+    Type.ReduxNew,
     string,
     string,
     number,
     number
 ];
-type Message = Timestamp | SetPageLocation | SetViewportSize | SetViewportScroll | CreateDocument | CreateElementNode | CreateTextNode | MoveNode | RemoveNode | SetNodeAttribute | RemoveNodeAttribute | SetNodeData | SetNodeScroll | SetInputTarget | SetInputValue | SetInputChecked | MouseMove | NetworkRequestDeprecated | ConsoleLog | PageLoadTiming | PageRenderTiming | CustomEvent | UserID | UserAnonymousID | Metadata | CSSInsertRule | CSSDeleteRule | Fetch | Profiler | OTable | StateAction | ReduxDeprecated | Vuex | MobX | NgRx | GraphQL | PerformanceTrack | StringDict | SetNodeAttributeDict | ResourceTimingDeprecated | ConnectionInformation | SetPageVisibility | LoadFontFace | SetNodeFocus | LongTask | SetNodeAttributeURLBased | SetCSSDataURLBased | TechnicalInfo | CustomIssue | CSSInsertRuleURLBased | MouseClick | CreateIFrameDocument | AdoptedSSReplaceURLBased | AdoptedSSInsertRuleURLBased | AdoptedSSDeleteRule | AdoptedSSAddOwner | AdoptedSSRemoveOwner | JSException | Zustand | BatchMetadata | PartitionedMessage | NetworkRequest | WSChannel | InputChange | SelectionChange | MouseThrashing | UnbindNodes | ResourceTiming | TabChange | TabData | CanvasNode | TagTrigger | Redux;
+type Message = Timestamp | SetPageLocation | SetViewportSize | SetViewportScroll | CreateDocument | CreateElementNode | CreateTextNode | MoveNode | RemoveNode | SetNodeAttribute | RemoveNodeAttribute | SetNodeData | SetNodeScroll | SetInputTarget | SetInputValue | SetInputChecked | MouseMove | NetworkRequestDeprecated | ConsoleLog | PageLoadTiming | PageRenderTiming | CustomEvent | UserID | UserAnonymousID | Metadata | CSSInsertRule | CSSDeleteRule | Fetch | Profiler | OTable | StateAction | Redux | Vuex | MobX | NgRx | GraphQL | PerformanceTrack | StringDict | SetNodeAttributeDict | ResourceTimingDeprecated | ConnectionInformation | SetPageVisibility | LoadFontFace | SetNodeFocus | LongTask | SetNodeAttributeURLBased | SetCSSDataURLBased | TechnicalInfo | CustomIssue | CSSInsertRuleURLBased | MouseClick | CreateIFrameDocument | AdoptedSSReplaceURLBased | AdoptedSSInsertRuleURLBased | AdoptedSSDeleteRule | AdoptedSSAddOwner | AdoptedSSRemoveOwner | JSException | Zustand | BatchMetadata | PartitionedMessage | NetworkRequest | WSChannel | InputChange | SelectionChange | MouseThrashing | UnbindNodes | ResourceTiming | TabChange | TabData | CanvasNode | TagTrigger | ReduxNew;
 export default Message;

package/cjs/index.js

@@ -97,7 +97,7 @@ class API {
             const orig = this.options.ingestPoint || index_js_1.DEFAULT_INGEST_POINT;
             req.open('POST', orig + '/v1/web/not-started');
             req.send(JSON.stringify({
-                trackerVersion: '12.0.11',
+                trackerVersion: '12.1.0-beta.99',
                 projectKey: this.options.projectKey,
                 doNotTrack,
                 reason: missingApi.length ? `missing api: ${missingApi.join(',')}` : reason,

package/lib/app/index.d.ts

@@ -11,7 +11,7 @@ import type { Options as ObserverOptions } from './observer/top_observer.js';
 import type { Options as SanitizerOptions } from './sanitizer.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>;
@@ -90,7 +90,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;
@@ -100,9 +100,10 @@ export default class App {
     private uxtManager;
     private conditionsManager;
     featureFlags: FeatureFlags;
-    private tagWatcher;
+    private readonly tagWatcher;
     constructor(projectKey: string, sessionToken: string | undefined, options: Partial<Options>, signalError: (error: string, apis: string[]) => void);
-    private _debug;
+    handleWorkerMsg(data: FromWorkerData): void;
+    private readonly _debug;
     private _usingOldFetchPlugin;
     send(message: Message, urgent?: boolean): void;
     /**
@@ -160,7 +161,7 @@ export default class App {
     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
+     * 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>;
@@ -178,7 +179,7 @@ export default class App {
     /**
      * 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
+     * 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
      * */