userlens-session-recorder 2.0.1 → 2.1.0

package/dist/types/index.d.ts

@@ -1,25 +1,49 @@
+import { eventWithTime } from 'rrweb';
+
 type MaskingOption = "passwords" | "all";
+type RecorderMode = "auto" | "manual";
 interface SessionRecordingOptions {
     TIMEOUT?: number;
     BUFFER_SIZE?: number;
     maskingOptions?: MaskingOption[];
     recordCrossOriginIframes?: boolean;
 }
-interface SessionRecorderConfig {
+interface EventBatch {
+    session_uuid: string;
+    chunk_seq: number;
+    chunk_start_ts: string;
+    chunk_end_ts: string;
+    initial_url?: string;
+    events: eventWithTime[];
+    keepalive?: boolean;
+}
+type OnEventsCallback = (batch: EventBatch) => void | Promise<void>;
+interface AutoModeConfig {
+    mode?: "auto";
     WRITE_CODE: string;
     userId: string;
     recordingOptions?: SessionRecordingOptions;
     debug?: boolean;
 }
+interface ManualModeConfig {
+    mode: "manual";
+    onEvents: OnEventsCallback;
+    recordingOptions?: SessionRecordingOptions;
+    debug?: boolean;
+}
+type SessionRecorderConfig = AutoModeConfig | ManualModeConfig;
 
 declare class SessionRecorder {
     #private;
+    private mode;
     private userId?;
+    private onEvents?;
     private TIMEOUT;
     private BUFFER_SIZE;
     private maskingOptions;
     private sessionUuid;
     private sessionEvents;
+    private bufferBytes;
     private rrwebStop;
     private debug;
     private recordCrossOriginIframes;
@@ -29,4 +53,4 @@ declare class SessionRecorder {
 }
 
 export { SessionRecorder as default };
-export type { MaskingOption, SessionRecorderConfig };
+export type { AutoModeConfig, EventBatch, ManualModeConfig, MaskingOption, OnEventsCallback, RecorderMode, SessionRecorderConfig };

package/dist/userlens-session-recorder.umd.js

@@ -20675,66 +20675,81 @@
         return "ok";
     };
 
-    var _SessionRecorder_instances, _SessionRecorder_trackEventsThrottled, _SessionRecorder_uploading, _SessionRecorder_uploadingMaxTs, _SessionRecorder_log, _SessionRecorder_initRecorder, _SessionRecorder_isUserInteraction, _SessionRecorder_handleEvent, _SessionRecorder_resetSession, _SessionRecorder_createSession, _SessionRecorder_handlePageHide, _SessionRecorder_initListeners, _SessionRecorder_throttle, _SessionRecorder_trackEvents, _SessionRecorder_clearEvents;
+    var _SessionRecorder_instances, _SessionRecorder_uploading, _SessionRecorder_uploadingMaxTs, _SessionRecorder_bufferTimer, _SessionRecorder_log, _SessionRecorder_initRecorder, _SessionRecorder_isUserInteraction, _SessionRecorder_handleEvent, _SessionRecorder_armBufferTimer, _SessionRecorder_flushBuffer, _SessionRecorder_resetSession, _SessionRecorder_createSession, _SessionRecorder_handlePageHide, _SessionRecorder_initListeners, _SessionRecorder_trackEvents, _SessionRecorder_clearEvents;
+    const BUFFER_TIMEOUT_MS = 2000;
+    const MAX_BUFFER_BYTES = 900 * 1024;
+    function estimateEventSize(event) {
+        try {
+            return JSON.stringify(event).length;
+        }
+        catch {
+            return 0;
+        }
+    }
     class SessionRecorder {
         constructor(config) {
             var _a, _b, _c;
             _SessionRecorder_instances.add(this);
             this.sessionEvents = [];
+            this.bufferBytes = 0;
             this.rrwebStop = null;
             this.debug = false;
-            _SessionRecorder_trackEventsThrottled.set(this, void 0);
             _SessionRecorder_uploading.set(this, false);
             _SessionRecorder_uploadingMaxTs.set(this, 0);
+            _SessionRecorder_bufferTimer.set(this, null);
             _SessionRecorder_handlePageHide.set(this, () => {
                 try {
                     if (this.sessionEvents.length === 0)
                         return;
-                    let toUpload;
+                    let events;
                     if (__classPrivateFieldGet(this, _SessionRecorder_uploading, "f") && __classPrivateFieldGet(this, _SessionRecorder_uploadingMaxTs, "f") > 0) {
-                        toUpload = this.sessionEvents.filter((e) => e.timestamp > __classPrivateFieldGet(this, _SessionRecorder_uploadingMaxTs, "f"));
+                        events = this.sessionEvents.filter((e) => e.timestamp > __classPrivateFieldGet(this, _SessionRecorder_uploadingMaxTs, "f"));
                     }
                     else {
-                        toUpload = [...this.sessionEvents];
+                        events = [...this.sessionEvents];
                     }
-                    if (toUpload.length === 0)
+                    if (events.length === 0)
                         return;
-                    let events;
-                    if (toUpload[0].type !== 4) {
-                        let snapshotPair = [];
-                        for (let i = this.sessionEvents.length - 2; i >= 0; i--) {
-                            if (this.sessionEvents[i].type === 4 &&
-                                this.sessionEvents[i + 1].type === 2) {
-                                snapshotPair = [
-                                    this.sessionEvents[i],
-                                    this.sessionEvents[i + 1],
-                                ];
-                                break;
-                            }
-                        }
-                        events = [...snapshotPair, ...toUpload];
-                    }
-                    else {
-                        events = toUpload;
-                    }
                     const state = readSessionState();
                     if (!state)
                         return;
                     const chunk_seq = __classPrivateFieldGet(this, _SessionRecorder_uploading, "f") ? state.chunk_seq + 1 : state.chunk_seq;
                     writeSessionState({ ...state, chunk_seq: chunk_seq + 1 });
-                    const start_ts_ms = toUpload[0].timestamp;
-                    const end_ts_ms = toUpload[toUpload.length - 1].timestamp;
-                    uploadSessionEvents({
-                        user_id: this.userId,
-                        session_uuid: this.sessionUuid,
-                        chunk_seq,
-                        chunk_start_ts: new Date(start_ts_ms).toISOString(),
-                        chunk_end_ts: new Date(end_ts_ms).toISOString(),
-                        initial_url: chunk_seq === 0 ? state.initial_url : undefined,
-                        events,
-                        keepalive: true,
-                    }).catch(() => { });
+                    const start_ts_ms = events[0].timestamp;
+                    const end_ts_ms = events[events.length - 1].timestamp;
+                    const initial_url = chunk_seq === 0 ? state.initial_url : undefined;
+                    const chunk_start_ts = new Date(start_ts_ms).toISOString();
+                    const chunk_end_ts = new Date(end_ts_ms).toISOString();
+                    if (this.mode === "manual") {
+                        try {
+                            void this.onEvents({
+                                session_uuid: this.sessionUuid,
+                                chunk_seq,
+                                chunk_start_ts,
+                                chunk_end_ts,
+                                initial_url,
+                                events,
+                                keepalive: true,
+                            });
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    else {
+                        uploadSessionEvents({
+                            user_id: this.userId,
+                            session_uuid: this.sessionUuid,
+                            chunk_seq,
+                            chunk_start_ts,
+                            chunk_end_ts,
+                            initial_url,
+                            events,
+                            keepalive: true,
+                        }).catch(() => { });
+                    }
                     this.sessionEvents = [];
+                    this.bufferBytes = 0;
                 }
                 catch (err) {
                     __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "Page hide handling failed", err);
@@ -20761,21 +20776,29 @@
                 sessionStorage.setItem(testKey, "1");
                 sessionStorage.removeItem(testKey);
                 this.debug = (_a = config.debug) !== null && _a !== void 0 ? _a : false;
-                if (!((_b = config.WRITE_CODE) === null || _b === void 0 ? void 0 : _b.trim()) || !((_c = config.userId) === null || _c === void 0 ? void 0 : _c.trim())) {
-                    return;
+                if (config.mode === "manual") {
+                    this.mode = "manual";
+                    if (!config.onEvents || typeof config.onEvents !== "function") {
+                        __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "onEvents callback is required in manual mode");
+                        return;
+                    }
+                    this.onEvents = config.onEvents;
+                }
+                else {
+                    this.mode = "auto";
+                    if (!((_b = config.WRITE_CODE) === null || _b === void 0 ? void 0 : _b.trim()) || !((_c = config.userId) === null || _c === void 0 ? void 0 : _c.trim())) {
+                        return;
+                    }
+                    saveWriteCode(config.WRITE_CODE);
+                    this.userId = config.userId;
                 }
-                saveWriteCode(config.WRITE_CODE);
-                this.userId = config.userId;
                 const { recordingOptions = {} } = config;
-                const { TIMEOUT = 30 * 60 * 1000, BUFFER_SIZE = 10, maskingOptions = ["passwords"], recordCrossOriginIframes = false, } = recordingOptions;
+                const { TIMEOUT = 30 * 60 * 1000, BUFFER_SIZE = 30, maskingOptions = ["passwords"], recordCrossOriginIframes = false, } = recordingOptions;
                 this.TIMEOUT = TIMEOUT;
                 this.BUFFER_SIZE = BUFFER_SIZE;
                 this.maskingOptions = maskingOptions;
                 this.recordCrossOriginIframes = recordCrossOriginIframes;
                 this.sessionEvents = [];
-                __classPrivateFieldSet(this, _SessionRecorder_trackEventsThrottled, __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_throttle).call(this, () => {
-                    __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_trackEvents).call(this);
-                }, 5000), "f");
                 __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_initRecorder).call(this);
             }
             catch (err) {
@@ -20802,7 +20825,7 @@
             }
         }
     }
-    _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_uploading = new WeakMap(), _SessionRecorder_uploadingMaxTs = new WeakMap(), _SessionRecorder_handlePageHide = new WeakMap(), _SessionRecorder_instances = new WeakSet(), _SessionRecorder_log = function _SessionRecorder_log(message, error) {
+    _SessionRecorder_uploading = new WeakMap(), _SessionRecorder_uploadingMaxTs = new WeakMap(), _SessionRecorder_bufferTimer = new WeakMap(), _SessionRecorder_handlePageHide = new WeakMap(), _SessionRecorder_instances = new WeakSet(), _SessionRecorder_log = function _SessionRecorder_log(message, error) {
         if (!this.debug)
             return;
         if (error) {
@@ -20825,6 +20848,7 @@
             },
             recordCrossOriginIframes: this.recordCrossOriginIframes,
             plugins: [getRecordConsolePlugin()],
+            checkoutEveryNth: 100,
         });
         __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_initListeners).call(this);
     }, _SessionRecorder_isUserInteraction = function _SessionRecorder_isUserInteraction(event) {
@@ -20835,7 +20859,6 @@
         }
         return false;
     }, _SessionRecorder_handleEvent = function _SessionRecorder_handleEvent(event, _isCheckout) {
-        var _a;
         try {
             const now = Date.now();
             const state = readSessionState();
@@ -20850,13 +20873,29 @@
                 }
             }
             this.sessionEvents.push(event);
-            if (this.sessionEvents.length >= this.BUFFER_SIZE) {
-                (_a = __classPrivateFieldGet(this, _SessionRecorder_trackEventsThrottled, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.bufferBytes += estimateEventSize(event);
+            __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_armBufferTimer).call(this);
+            if (this.bufferBytes >= MAX_BUFFER_BYTES) {
+                __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_flushBuffer).call(this);
             }
         }
         catch (err) {
             __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "Event handling failed", err);
         }
+    }, _SessionRecorder_armBufferTimer = function _SessionRecorder_armBufferTimer() {
+        if (__classPrivateFieldGet(this, _SessionRecorder_bufferTimer, "f") !== null) {
+            clearTimeout(__classPrivateFieldGet(this, _SessionRecorder_bufferTimer, "f"));
+        }
+        __classPrivateFieldSet(this, _SessionRecorder_bufferTimer, setTimeout(() => {
+            __classPrivateFieldSet(this, _SessionRecorder_bufferTimer, null, "f");
+            __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_flushBuffer).call(this);
+        }, BUFFER_TIMEOUT_MS), "f");
+    }, _SessionRecorder_flushBuffer = function _SessionRecorder_flushBuffer() {
+        if (__classPrivateFieldGet(this, _SessionRecorder_bufferTimer, "f") !== null) {
+            clearTimeout(__classPrivateFieldGet(this, _SessionRecorder_bufferTimer, "f"));
+            __classPrivateFieldSet(this, _SessionRecorder_bufferTimer, null, "f");
+        }
+        void __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_trackEvents).call(this);
     }, _SessionRecorder_resetSession = function _SessionRecorder_resetSession() {
         clearSessionState();
         __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_clearEvents).call(this);
@@ -20881,15 +20920,6 @@
         }
     }, _SessionRecorder_initListeners = function _SessionRecorder_initListeners() {
         window.addEventListener("pagehide", __classPrivateFieldGet(this, _SessionRecorder_handlePageHide, "f"));
-    }, _SessionRecorder_throttle = function _SessionRecorder_throttle(func, delay) {
-        let lastCall = 0;
-        return (...args) => {
-            const now = Date.now();
-            if (now - lastCall >= delay) {
-                lastCall = now;
-                func.apply(this, args);
-            }
-        };
     }, _SessionRecorder_trackEvents = async function _SessionRecorder_trackEvents() {
         if (__classPrivateFieldGet(this, _SessionRecorder_uploading, "f"))
             return;
@@ -20908,26 +20938,33 @@
                 return;
             }
             const chunk_seq = state.chunk_seq;
-            await uploadSessionEvents({
-                user_id: this.userId,
-                session_uuid: this.sessionUuid,
-                chunk_seq,
-                chunk_start_ts: new Date(start_ts_ms).toISOString(),
-                chunk_end_ts: new Date(end_ts_ms).toISOString(),
-                initial_url: chunk_seq === 0 ? state.initial_url : undefined,
-                events,
-            });
-            const remaining = this.sessionEvents.slice(snapshot_count);
-            this.sessionEvents = [];
-            try {
-                takeFullSnapshot(true);
-            }
-            catch (err) {
-                __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "takeFullSnapshot failed", err);
+            const initial_url = chunk_seq === 0 ? state.initial_url : undefined;
+            const chunk_start_ts = new Date(start_ts_ms).toISOString();
+            const chunk_end_ts = new Date(end_ts_ms).toISOString();
+            if (this.mode === "manual") {
+                await this.onEvents({
+                    session_uuid: this.sessionUuid,
+                    chunk_seq,
+                    chunk_start_ts,
+                    chunk_end_ts,
+                    initial_url,
+                    events,
+                });
             }
-            if (remaining.length > 0) {
-                this.sessionEvents.push(...remaining);
+            else {
+                await uploadSessionEvents({
+                    user_id: this.userId,
+                    session_uuid: this.sessionUuid,
+                    chunk_seq,
+                    chunk_start_ts,
+                    chunk_end_ts,
+                    initial_url,
+                    events,
+                });
             }
+            const removedBytes = events.reduce((sum, e) => sum + estimateEventSize(e), 0);
+            this.sessionEvents = this.sessionEvents.slice(snapshot_count);
+            this.bufferBytes = Math.max(0, this.bufferBytes - removedBytes);
             const after = readSessionState();
             if (after &&
                 after.session_uuid === state.session_uuid &&
@@ -20944,6 +20981,11 @@
         }
     }, _SessionRecorder_clearEvents = function _SessionRecorder_clearEvents() {
         this.sessionEvents = [];
+        this.bufferBytes = 0;
+        if (__classPrivateFieldGet(this, _SessionRecorder_bufferTimer, "f") !== null) {
+            clearTimeout(__classPrivateFieldGet(this, _SessionRecorder_bufferTimer, "f"));
+            __classPrivateFieldSet(this, _SessionRecorder_bufferTimer, null, "f");
+        }
     };
 
     exports.default = SessionRecorder;