userlens-session-recorder 2.0.1 → 2.0.2

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export default class SessionRecorder {
     private maskingOptions;
     private sessionUuid;
     private sessionEvents;
+    private bufferBytes;
     private rrwebStop;
     private debug;
     private recordCrossOriginIframes;

package/dist/index.esm.js

@@ -20669,55 +20669,48 @@ const uploadSessionEvents = async (args) => {
     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;
+                const start_ts_ms = events[0].timestamp;
+                const end_ts_ms = events[events.length - 1].timestamp;
                 uploadSessionEvents({
                     user_id: this.userId,
                     session_uuid: this.sessionUuid,
@@ -20729,6 +20722,7 @@ class SessionRecorder {
                     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,15 +20755,12 @@ class SessionRecorder {
             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) {
@@ -20796,7 +20787,7 @@ class SessionRecorder {
         }
     }
 }
-_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) {
@@ -20819,6 +20810,7 @@ _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_uploadin
         },
         recordCrossOriginIframes: this.recordCrossOriginIframes,
         plugins: [getRecordConsolePlugin()],
+        checkoutEveryNth: 100,
     });
     __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_initListeners).call(this);
 }, _SessionRecorder_isUserInteraction = function _SessionRecorder_isUserInteraction(event) {
@@ -20829,7 +20821,6 @@ _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_uploadin
     }
     return false;
 }, _SessionRecorder_handleEvent = function _SessionRecorder_handleEvent(event, _isCheckout) {
-    var _a;
     try {
         const now = Date.now();
         const state = readSessionState();
@@ -20844,13 +20835,29 @@ _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_uploadin
             }
         }
         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);
@@ -20875,15 +20882,6 @@ _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_uploadin
     }
 }, _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;
@@ -20911,17 +20909,9 @@ _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_uploadin
             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);
-        }
-        if (remaining.length > 0) {
-            this.sessionEvents.push(...remaining);
-        }
+        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 &&
@@ -20938,6 +20928,11 @@ _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_uploadin
     }
 }, _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");
+    }
 };
 
 export { SessionRecorder as default };