mixpanel-browser 2.59.0 → 2.61.0

package/src/mixpanel-persistence.js

@@ -345,8 +345,12 @@ MixpanelPersistence.prototype._add_to_people_queue = function(queue, data) {
                 if (!(k in union_q)) {
                     union_q[k] = [];
                 }
-                // We may send duplicates, the server will dedup them.
-                union_q[k] = union_q[k].concat(v);
+                // Prevent duplicate values
+                _.each(v, function(item) {
+                    if (!_.include(union_q[k], item)) {
+                        union_q[k].push(item);
+                    }
+                });
             }
         });
         this._pop_from_people_queue(UNSET_ACTION, q_data);

package/src/recorder/index.js

@@ -1,73 +1,4 @@
-import {record} from 'rrweb';
-
-import { SessionRecording } from './session-recording';
-import { console_with_prefix, _ } from '../utils'; // eslint-disable-line camelcase
 import { window } from '../window';
-
-var logger = console_with_prefix('recorder');
-
-/**
- * Recorder API: manages recordings and exposes methods public to the core Mixpanel library.
- * @param {Object} [options.mixpanelInstance] - reference to the core MixpanelLib
- */
-var MixpanelRecorder = function(mixpanelInstance) {
-    this._mixpanel = mixpanelInstance;
-    this.activeRecording = null;
-};
-
-MixpanelRecorder.prototype.startRecording = function(shouldStopBatcher) {
-    if (this.activeRecording && !this.activeRecording.isRrwebStopped()) {
-        logger.log('Recording already in progress, skipping startRecording.');
-        return;
-    }
-
-    var onIdleTimeout = _.bind(function () {
-        logger.log('Idle timeout reached, restarting recording.');
-        this.resetRecording();
-    }, this);
-
-    var onMaxLengthReached = _.bind(function () {
-        logger.log('Max recording length reached, stopping recording.');
-        this.resetRecording();
-    }, this);
-
-    this.activeRecording = new SessionRecording({
-        mixpanelInstance: this._mixpanel,
-        onIdleTimeout: onIdleTimeout,
-        onMaxLengthReached: onMaxLengthReached,
-        replayId: _.UUID(),
-        rrwebRecord: record
-    });
-
-    this.activeRecording.startRecording(shouldStopBatcher);
-};
-
-MixpanelRecorder.prototype.stopRecording = function() {
-    if (this.activeRecording) {
-        this.activeRecording.stopRecording();
-        this.activeRecording = null;
-    }
-};
-
-MixpanelRecorder.prototype.resetRecording = function () {
-    this.stopRecording();
-    this.startRecording(true);
-};
-
-MixpanelRecorder.prototype.getActiveReplayId = function () {
-    if (this.activeRecording && !this.activeRecording.isRrwebStopped()) {
-        return this.activeRecording.replayId;
-    } else {
-        return null;
-    }
-};
-
-// getter so that older mixpanel-core versions can still retrieve the replay ID
-// when pulling the latest recorder bundle from the CDN
-Object.defineProperty(MixpanelRecorder.prototype, 'replayId', {
-    get: function () {
-        return this.getActiveReplayId();
-    }
-});
+import { MixpanelRecorder } from './recorder';
 
 window['__mp_recorder'] = MixpanelRecorder;

package/src/recorder/recorder.js

@@ -0,0 +1,137 @@
+import { record } from 'rrweb';
+import { Promise } from '../promise-polyfill';
+import { SessionRecording } from './session-recording';
+import { RecordingRegistry } from './recording-registry';
+
+import { console_with_prefix, _ } from '../utils'; // eslint-disable-line camelcase
+
+var logger = console_with_prefix('recorder');
+
+/**
+ * Recorder API: bundles rrweb and and exposes methods to start and stop recordings.
+ * @param {Object} [options.mixpanelInstance] - reference to the core MixpanelLib
+*/
+var MixpanelRecorder = function(mixpanelInstance, rrwebRecord, sharedLockStorage) {
+    this.mixpanelInstance = mixpanelInstance;
+    this.rrwebRecord = rrwebRecord || record;
+    this.sharedLockStorage = sharedLockStorage;
+
+    /**
+     * @member {import('./registry').RecordingRegistry}
+     */
+    this.recordingRegistry = new RecordingRegistry({
+        mixpanelInstance: this.mixpanelInstance,
+        errorReporter: logger.error,
+        sharedLockStorage: sharedLockStorage
+    });
+    this._flushInactivePromise = this.recordingRegistry.flushInactiveRecordings();
+
+    this.activeRecording = null;
+};
+
+MixpanelRecorder.prototype.startRecording = function(options) {
+    options = options || {};
+    if (this.activeRecording && !this.activeRecording.isRrwebStopped()) {
+        logger.log('Recording already in progress, skipping startRecording.');
+        return;
+    }
+
+    var onIdleTimeout = function () {
+        logger.log('Idle timeout reached, restarting recording.');
+        this.resetRecording();
+    }.bind(this);
+
+    var onMaxLengthReached = function () {
+        logger.log('Max recording length reached, stopping recording.');
+        this.resetRecording();
+    }.bind(this);
+
+    var onBatchSent = function () {
+        this.recordingRegistry.setActiveRecording(this.activeRecording.serialize());
+        this['__flushPromise'] = this.activeRecording.batcher._flushPromise;
+    }.bind(this);
+
+    /**
+     * @type {import('./session-recording').SessionRecordingOptions}
+     */
+    var sessionRecordingOptions = {
+        mixpanelInstance: this.mixpanelInstance,
+        onBatchSent: onBatchSent,
+        onIdleTimeout: onIdleTimeout,
+        onMaxLengthReached: onMaxLengthReached,
+        replayId: _.UUID(),
+        rrwebRecord: this.rrwebRecord,
+        sharedLockStorage: this.sharedLockStorage
+    };
+
+    if (options.activeSerializedRecording) {
+        this.activeRecording = SessionRecording.deserialize(options.activeSerializedRecording, sessionRecordingOptions);
+    } else {
+        this.activeRecording = new SessionRecording(sessionRecordingOptions);
+    }
+
+    this.activeRecording.startRecording(options.shouldStopBatcher);
+    return this.recordingRegistry.setActiveRecording(this.activeRecording.serialize());
+};
+
+MixpanelRecorder.prototype.stopRecording = function() {
+    var stopPromise = this._stopCurrentRecording(false);
+    this.recordingRegistry.clearActiveRecording();
+    this.activeRecording = null;
+    return stopPromise;
+};
+
+MixpanelRecorder.prototype.pauseRecording = function() {
+    return this._stopCurrentRecording(false);
+};
+
+MixpanelRecorder.prototype._stopCurrentRecording = function(skipFlush) {
+    if (this.activeRecording) {
+        return this.activeRecording.stopRecording(skipFlush);
+    }
+    return Promise.resolve();
+};
+
+MixpanelRecorder.prototype.resumeRecording = function (startNewIfInactive) {
+    if (this.activeRecording && this.activeRecording.isRrwebStopped()) {
+        this.activeRecording.startRecording(false);
+        return Promise.resolve(null);
+    }
+
+    return this.recordingRegistry.getActiveRecording()
+        .then(function (activeSerializedRecording) {
+            if (activeSerializedRecording) {
+                return this.startRecording({activeSerializedRecording: activeSerializedRecording});
+            } else if (startNewIfInactive) {
+                return this.startRecording({shouldStopBatcher: false});
+            } else {
+                logger.log('No resumable recording found.');
+                return null;
+            }
+        }.bind(this));
+};
+
+
+MixpanelRecorder.prototype.resetRecording = function () {
+    this.stopRecording();
+    this.startRecording({shouldStopBatcher: true});
+};
+
+MixpanelRecorder.prototype.getActiveReplayId = function () {
+    if (this.activeRecording && !this.activeRecording.isRrwebStopped()) {
+        return this.activeRecording.replayId;
+    } else {
+        return null;
+    }
+};
+
+// getter so that older mixpanel-core versions can still retrieve the replay ID
+// when pulling the latest recorder bundle from the CDN
+Object.defineProperty(MixpanelRecorder.prototype, 'replayId', {
+    get: function () {
+        return this.getActiveReplayId();
+    }
+});
+
+
+export { MixpanelRecorder };

package/src/recorder/recording-registry.js

@@ -0,0 +1,98 @@
+import { Promise } from '../promise-polyfill';
+import { IDBStorageWrapper, RECORDING_REGISTRY_STORE_NAME } from '../storage/indexed-db';
+import { SessionRecording } from './session-recording';
+import { isRecordingExpired } from './utils';
+
+/**
+ * Module for handling the storage and retrieval of recording metadata as well as any active recordings.
+ * Makes sure that only one tab can be recording at a time.
+ */
+var RecordingRegistry = function (options) {
+    this.idb = new IDBStorageWrapper(RECORDING_REGISTRY_STORE_NAME);
+    this.errorReporter = options.errorReporter;
+    this.mixpanelInstance = options.mixpanelInstance;
+    this.sharedLockStorage = options.sharedLockStorage;
+};
+
+RecordingRegistry.prototype.handleError = function (err) {
+    this.errorReporter('IndexedDB error: ', err);
+};
+
+/**
+ * @param {import('./session-recording').SerializedRecording} serializedRecording
+ */
+RecordingRegistry.prototype.setActiveRecording = function (serializedRecording) {
+    var tabId = serializedRecording['tabId'];
+    if (!tabId) {
+        console.warn('No tab ID is set, cannot persist recording metadata.');
+        return Promise.resolve();
+    }
+
+    return this.idb.init()
+        .then(function () {
+            return this.idb.setItem(tabId, serializedRecording);
+        }.bind(this))
+        .catch(this.handleError.bind(this));
+};
+
+/**
+ * @returns {Promise<import('./session-recording').SerializedRecording>}
+ */
+RecordingRegistry.prototype.getActiveRecording = function () {
+    return this.idb.init()
+        .then(function () {
+            return this.idb.getItem(this.mixpanelInstance.get_tab_id());
+        }.bind(this))
+        .then(function (serializedRecording) {
+            return isRecordingExpired(serializedRecording) ? null : serializedRecording;
+        }.bind(this))
+        .catch(this.handleError.bind(this));
+};
+
+RecordingRegistry.prototype.clearActiveRecording = function () {
+    // mark recording as expired instead of deleting it in case the page unloads mid-flush and doesn't make it to ingestion.
+    // this will ensure the next pageload will flush the remaining events, but not try to continue the recording.
+    return this.getActiveRecording()
+        .then(function (serializedRecording) {
+            if (serializedRecording) {
+                serializedRecording['maxExpires'] = 0;
+                return this.setActiveRecording(serializedRecording);
+            }
+        }.bind(this))
+        .catch(this.handleError.bind(this));
+};
+
+/**
+ * Flush any inactive recordings from the registry to minimize data loss.
+ * The main idea here is that we can flush remaining rrweb events on the next page load if a tab is closed mid-batch.
+ */
+RecordingRegistry.prototype.flushInactiveRecordings = function () {
+    return this.idb.init()
+        .then(function() {
+            return this.idb.getAll();
+        }.bind(this))
+        .then(function (serializedRecordings) {
+            // clean up any expired recordings from the registry, non-expired ones may be active in other tabs
+            var unloadPromises = serializedRecordings
+                .filter(function (serializedRecording) {
+                    return isRecordingExpired(serializedRecording);
+                })
+                .map(function (serializedRecording) {
+                    var sessionRecording = SessionRecording.deserialize(serializedRecording, {
+                        mixpanelInstance: this.mixpanelInstance,
+                        sharedLockStorage: this.sharedLockStorage
+                    });
+                    return sessionRecording.unloadPersistedData()
+                        .then(function () {
+                            // expired recording was successfully flushed, we can clean it up from the registry
+                            return this.idb.removeItem(serializedRecording['tabId']);
+                        }.bind(this))
+                        .catch(this.handleError.bind(this));
+                }.bind(this));
+
+            return Promise.all(unloadPromises);
+        }.bind(this))
+        .catch(this.handleError.bind(this));
+};
+
+export { RecordingRegistry };

package/src/recorder/session-recording.js

@@ -1,10 +1,11 @@
-import { IncrementalSource, EventType } from '@rrweb/types';
-
-import { MAX_RECORDING_MS, MAX_VALUE_FOR_MIN_RECORDING_MS, console_with_prefix, _} from '../utils'; // eslint-disable-line camelcase
 import { window } from '../window';
+import { IncrementalSource, EventType } from '@rrweb/types';
+import { MAX_RECORDING_MS, MAX_VALUE_FOR_MIN_RECORDING_MS, console_with_prefix, NOOP_FUNC, _, localStorageSupported} from '../utils'; // eslint-disable-line camelcase
+import { IDBStorageWrapper, RECORDING_EVENTS_STORE_NAME } from '../storage/indexed-db';
 import { addOptOutCheckMixpanelLib } from '../gdpr-utils';
 import { RequestBatcher } from '../request-batcher';
 import Config from '../config';
+import { RECORD_ENQUEUE_THROTTLE_MS } from './utils';
 
 var logger = console_with_prefix('recorder');
 var CompressionStream = window['CompressionStream'];
@@ -32,29 +33,58 @@ function isUserEvent(ev) {
     return ev.type === EventType.IncrementalSnapshot && ACTIVE_SOURCES.has(ev.data.source);
 }
 
+/**
+ * @typedef {Object} SerializedRecording
+ * @property {number} idleExpires
+ * @property {number} maxExpires
+ * @property {number} replayStartTime
+ * @property {number} seqNo
+ * @property {string} batchStartUrl
+ * @property {string} replayId
+ * @property {string} tabId
+ * @property {string} replayStartUrl
+ */
+
+/**
+ * @typedef {Object} SessionRecordingOptions
+ * @property {Object} [options.mixpanelInstance] - reference to the core MixpanelLib
+ * @property {String} [options.replayId] - unique uuid for a single replay
+ * @property {Function} [options.onIdleTimeout] - callback when a recording reaches idle timeout
+ * @property {Function} [options.onMaxLengthReached] - callback when a recording reaches its maximum length
+ * @property {Function} [options.rrwebRecord] - rrweb's `record` function
+ * @property {Function} [options.onBatchSent] - callback when a batch of events is sent to the server
+ * @property {Storage} [options.sharedLockStorage] - optional storage for shared lock, used for test dependency injection
+ * optional properties for deserialization:
+ * @property {number} idleExpires
+ * @property {number} maxExpires
+ * @property {number} replayStartTime
+ * @property {number} seqNo
+ * @property {string} batchStartUrl
+ * @property {string} replayStartUrl
+ */
+
+
 /**
  * This class encapsulates a single session recording and its lifecycle.
- * @param {Object} [options.mixpanelInstance] - reference to the core MixpanelLib
- * @param {String} [options.replayId] - unique uuid for a single replay
- * @param {Function} [options.onIdleTimeout] - callback when a recording reaches idle timeout
- * @param {Function} [options.onMaxLengthReached] - callback when a recording reaches its maximum length
- * @param {Function} [options.rrwebRecord] - rrweb's `record` function
+ * @param {SessionRecordingOptions} options
  */
 var SessionRecording = function(options) {
     this._mixpanel = options.mixpanelInstance;
-    this._onIdleTimeout = options.onIdleTimeout;
-    this._onMaxLengthReached = options.onMaxLengthReached;
-    this._rrwebRecord = options.rrwebRecord;
-
-    this.replayId = options.replayId;
+    this._onIdleTimeout = options.onIdleTimeout || NOOP_FUNC;
+    this._onMaxLengthReached = options.onMaxLengthReached || NOOP_FUNC;
+    this._onBatchSent = options.onBatchSent || NOOP_FUNC;
+    this._rrwebRecord = options.rrwebRecord || null;
 
     // internal rrweb stopRecording function
     this._stopRecording = null;
+    this.replayId = options.replayId;
 
-    this.seqNo = 0;
-    this.replayStartTime = null;
-    this.replayStartUrl = null;
-    this.batchStartUrl = null;
+    this.batchStartUrl = options.batchStartUrl || null;
+    this.replayStartUrl = options.replayStartUrl || null;
+    this.idleExpires = options.idleExpires || null;
+    this.maxExpires = options.maxExpires || null;
+    this.replayStartTime = options.replayStartTime || null;
+    this.seqNo = options.seqNo || 0;
 
     this.idleTimeoutId = null;
     this.maxTimeoutId = null;
@@ -62,18 +92,40 @@ var SessionRecording = function(options) {
     this.recordMaxMs = MAX_RECORDING_MS;
     this.recordMinMs = 0;
 
+    // disable persistence if localStorage is not supported
+    // request-queue will automatically disable persistence if indexedDB fails to initialize
+    var usePersistence = localStorageSupported(options.sharedLockStorage, true);
+
     // each replay has its own batcher key to avoid conflicts between rrweb events of different recordings
     // this will be important when persistence is introduced
-    var batcherKey = '__mprec_' + this.getConfig('token') + '_' + this.replayId;
-    this.batcher = new RequestBatcher(batcherKey, {
-        errorReporter: _.bind(this.reportError, this),
+    this.batcherKey = '__mprec_' + this.getConfig('name') + '_' + this.getConfig('token') + '_' + this.replayId;
+    this.queueStorage = new IDBStorageWrapper(RECORDING_EVENTS_STORE_NAME);
+    this.batcher = new RequestBatcher(this.batcherKey, {
+        errorReporter: this.reportError.bind(this),
         flushOnlyOnInterval: true,
         libConfig: RECORDER_BATCHER_LIB_CONFIG,
-        sendRequestFunc: _.bind(this.flushEventsWithOptOut, this),
-        usePersistence: false
+        sendRequestFunc: this.flushEventsWithOptOut.bind(this),
+        queueStorage: this.queueStorage,
+        sharedLockStorage: options.sharedLockStorage,
+        usePersistence: usePersistence,
+        stopAllBatchingFunc: this.stopRecording.bind(this),
+
+        // increased throttle and shared lock timeout because recording events are very high frequency.
+        // this will minimize the amount of lock contention between enqueued events.
+        // for session recordings there is a lock for each tab anyway, so there's no risk of deadlock between tabs.
+        enqueueThrottleMs: RECORD_ENQUEUE_THROTTLE_MS,
+        sharedLockTimeoutMS: 10 * 1000,
     });
 };
 
+SessionRecording.prototype.unloadPersistedData = function () {
+    this.batcher.stop();
+    return this.batcher.flush()
+        .then(function () {
+            return this.queueStorage.removeItem(this.batcherKey);
+        }.bind(this));
+};
+
 SessionRecording.prototype.getConfig = function(configVar) {
     return this._mixpanel.get_config(configVar);
 };
@@ -86,6 +138,11 @@ SessionRecording.prototype.get_config = function(configVar) {
 };
 
 SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
+    if (this._rrwebRecord === null) {
+        this.reportError('rrweb record function not provided. ');
+        return;
+    }
+
     if (this._stopRecording !== null) {
         logger.log('Recording already in progress, skipping startRecording.');
         return;
@@ -97,15 +154,21 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
         logger.critical('record_max_ms cannot be greater than ' + MAX_RECORDING_MS + 'ms. Capping value.');
     }
 
+    if (!this.maxExpires) {
+        this.maxExpires = new Date().getTime() + this.recordMaxMs;
+    }
+
     this.recordMinMs = this.getConfig('record_min_ms');
     if (this.recordMinMs > MAX_VALUE_FOR_MIN_RECORDING_MS) {
         this.recordMinMs = MAX_VALUE_FOR_MIN_RECORDING_MS;
         logger.critical('record_min_ms cannot be greater than ' + MAX_VALUE_FOR_MIN_RECORDING_MS + 'ms. Capping value.');
     }
 
-    this.replayStartTime = new Date().getTime();
-    this.batchStartUrl = _.info.currentUrl();
-    this.replayStartUrl = _.info.currentUrl();
+    if (!this.replayStartTime) {
+        this.replayStartTime = new Date().getTime();
+        this.batchStartUrl = _.info.currentUrl();
+        this.replayStartUrl = _.info.currentUrl();
+    }
 
     if (shouldStopBatcher || this.recordMinMs > 0) {
         // the primary case for shouldStopBatcher is when we're starting recording after a reset
@@ -118,10 +181,12 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
         this.batcher.start();
     }
 
-    var resetIdleTimeout = _.bind(function () {
+    var resetIdleTimeout = function () {
         clearTimeout(this.idleTimeoutId);
-        this.idleTimeoutId = setTimeout(this._onIdleTimeout, this.getConfig('record_idle_timeout_ms'));
-    }, this);
+        var idleTimeoutMs = this.getConfig('record_idle_timeout_ms');
+        this.idleTimeoutId = setTimeout(this._onIdleTimeout, idleTimeoutMs);
+        this.idleExpires = new Date().getTime() + idleTimeoutMs;
+    }.bind(this);
 
     var blockSelector = this.getConfig('record_block_selector');
     if (blockSelector === '' || blockSelector === null) {
@@ -129,8 +194,7 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
     }
 
     this._stopRecording = this._rrwebRecord({
-        'emit': _.bind(function (ev) {
-            this.batcher.enqueue(ev);
+        'emit': addOptOutCheckMixpanelLib(function (ev) {
             if (isUserEvent(ev)) {
                 if (this.batcher.stopped && new Date().getTime() - this.replayStartTime >= this.recordMinMs) {
                     // start flushing again after user activity
@@ -138,7 +202,10 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
                 }
                 resetIdleTimeout();
             }
-        }, this),
+
+            // promise only used to await during tests
+            this.__enqueuePromise = this.batcher.enqueue(ev);
+        }.bind(this)),
         'blockClass': this.getConfig('record_block_class'),
         'blockSelector': blockSelector,
         'collectFonts': this.getConfig('record_collect_fonts'),
@@ -164,10 +231,11 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
 
     resetIdleTimeout();
 
-    this.maxTimeoutId = setTimeout(_.bind(this._onMaxLengthReached, this), this.recordMaxMs);
+    var maxTimeoutMs = this.maxExpires - new Date().getTime();
+    this.maxTimeoutId = setTimeout(this._onMaxLengthReached.bind(this), maxTimeoutMs);
 };
 
-SessionRecording.prototype.stopRecording = function () {
+SessionRecording.prototype.stopRecording = function (skipFlush) {
     if (!this.isRrwebStopped()) {
         try {
             this._stopRecording();
@@ -177,17 +245,19 @@ SessionRecording.prototype.stopRecording = function () {
         this._stopRecording = null;
     }
 
+    var flushPromise;
     if (this.batcher.stopped) {
         // never got user activity to flush after reset, so just clear the batcher
-        this.batcher.clear();
-    } else {
+        flushPromise = this.batcher.clear();
+    } else if (!skipFlush) {
         // flush any remaining events from running batcher
-        this.batcher.flush();
-        this.batcher.stop();
+        flushPromise = this.batcher.flush();
     }
+    this.batcher.stop();
 
     clearTimeout(this.idleTimeoutId);
     clearTimeout(this.maxTimeoutId);
+    return flushPromise;
 };
 
 SessionRecording.prototype.isRrwebStopped = function () {
@@ -199,7 +269,54 @@ SessionRecording.prototype.isRrwebStopped = function () {
  * we stop recording and dump any queued events if the user has opted out.
  */
 SessionRecording.prototype.flushEventsWithOptOut = function (data, options, cb) {
-    this._flushEvents(data, options, cb, _.bind(this._onOptOut, this));
+    this._flushEvents(data, options, cb, this._onOptOut.bind(this));
+};
+
+/**
+ * @returns {SerializedRecording}
+ */
+SessionRecording.prototype.serialize = function () {
+    // don't break if mixpanel instance was destroyed at some point
+    var tabId;
+    try {
+        tabId = this._mixpanel.get_tab_id();
+    } catch (e) {
+        this.reportError('Error getting tab ID for serialization ', e);
+        tabId = null;
+    }
+
+    return {
+        'replayId': this.replayId,
+        'seqNo': this.seqNo,
+        'replayStartTime': this.replayStartTime,
+        'batchStartUrl': this.batchStartUrl,
+        'replayStartUrl': this.replayStartUrl,
+        'idleExpires': this.idleExpires,
+        'maxExpires': this.maxExpires,
+        'tabId': tabId,
+    };
+};
+
+
+/**
+ * @static
+ * @param {SerializedRecording} serializedRecording
+ * @param {SessionRecordingOptions} options
+ * @returns {SessionRecording}
+ */
+SessionRecording.deserialize = function (serializedRecording, options) {
+    var recording = new SessionRecording(_.extend({}, options, {
+        replayId: serializedRecording['replayId'],
+        batchStartUrl: serializedRecording['batchStartUrl'],
+        replayStartUrl: serializedRecording['replayStartUrl'],
+        idleExpires: serializedRecording['idleExpires'],
+        maxExpires: serializedRecording['maxExpires'],
+        replayStartTime: serializedRecording['replayStartTime'],
+        seqNo: serializedRecording['seqNo'],
+        sharedLockStorage: options.sharedLockStorage,
+    }));
+
+    return recording;
 };
 
 SessionRecording.prototype._onOptOut = function (code) {
@@ -210,7 +327,7 @@ SessionRecording.prototype._onOptOut = function (code) {
 };
 
 SessionRecording.prototype._sendRequest = function(currentReplayId, reqParams, reqBody, callback) {
-    var onSuccess = _.bind(function (response, responseBody) {
+    var onSuccess = function (response, responseBody) {
         // Update batch specific props only if the request was successful to guarantee ordering.
         // RequestBatcher will always flush the next batch after the previous one succeeds.
         // extra check to see if the replay ID has changed so that we don't increment the seqNo on the wrong replay
@@ -218,13 +335,15 @@ SessionRecording.prototype._sendRequest = function(currentReplayId, reqParams, r
             this.seqNo++;
             this.batchStartUrl = _.info.currentUrl();
         }
+
+        this._onBatchSent();
         callback({
             status: 0,
             httpStatusCode: response.status,
             responseBody: responseBody,
             retryAfter: response.headers.get('Retry-After')
         });
-    }, this);
+    }.bind(this);
 
     window['fetch'](this.getConfig('api_host') + '/' + this.getConfig('api_routes')['record'] + '?' + new URLSearchParams(reqParams), {
         'method': 'POST',
@@ -245,7 +364,7 @@ SessionRecording.prototype._sendRequest = function(currentReplayId, reqParams, r
 };
 
 SessionRecording.prototype._flushEvents = addOptOutCheckMixpanelLib(function (data, options, callback) {
-    const numEvents = data.length;
+    var numEvents = data.length;
 
     if (numEvents > 0) {
         var replayId = this.replayId;
@@ -290,10 +409,10 @@ SessionRecording.prototype._flushEvents = addOptOutCheckMixpanelLib(function (da
             var gzipStream = jsonStream.pipeThrough(new CompressionStream('gzip'));
             new Response(gzipStream)
                 .blob()
-                .then(_.bind(function(compressedBlob) {
+                .then(function(compressedBlob) {
                     reqParams['format'] = 'gzip';
                     this._sendRequest(replayId, reqParams, compressedBlob, callback);
-                }, this));
+                }.bind(this));
         } else {
             reqParams['format'] = 'body';
             this._sendRequest(replayId, reqParams, eventsJson, callback);

package/src/recorder/utils.js

@@ -0,0 +1,12 @@
+/**
+ * @param {import('./session-recording').SerializedRecording} serializedRecording
+ * @returns {boolean}
+ */
+var isRecordingExpired = function(serializedRecording) {
+    var now = Date.now();
+    return !serializedRecording || now > serializedRecording['maxExpires'] || now > serializedRecording['idleExpires'];
+};
+
+var RECORD_ENQUEUE_THROTTLE_MS = 250;
+
+export { isRecordingExpired, RECORD_ENQUEUE_THROTTLE_MS};