@amplitude/session-replay-browser 1.2.1 → 1.2.3

package/lib/esm/session-replay.js

@@ -1,54 +1,23 @@
-import { __assign, __awaiter, __generator, __read } from "tslib";
+import { __awaiter, __generator } from "tslib";
 import { getAnalyticsConnector, getGlobalScope } from '@amplitude/analytics-client-common';
-import { BaseTransport, Logger, returnWrapper } from '@amplitude/analytics-core';
-import { ServerZone, Status } from '@amplitude/analytics-types';
+import { Logger, returnWrapper } from '@amplitude/analytics-core';
 import { pack, record } from '@amplitude/rrweb';
-import * as IDBKeyVal from 'idb-keyval';
 import { SessionReplayConfig } from './config';
-import { BLOCK_CLASS, DEFAULT_SAMPLE_RATE, DEFAULT_SESSION_REPLAY_PROPERTY, MASK_TEXT_CLASS, MAX_EVENT_LIST_SIZE_IN_BYTES, MAX_IDB_STORAGE_LENGTH, MAX_INTERVAL, MIN_INTERVAL, SESSION_REPLAY_DEBUG_PROPERTY, SESSION_REPLAY_EU_URL as SESSION_REPLAY_EU_SERVER_URL, SESSION_REPLAY_SERVER_URL, SESSION_REPLAY_STAGING_URL as SESSION_REPLAY_STAGING_SERVER_URL, STORAGE_PREFIX, defaultSessionStore, } from './constants';
-import { generateHashCode, generateSessionReplayId, getCurrentUrl, isSessionInSample, maskInputFn } from './helpers';
-import { MAX_RETRIES_EXCEEDED_MESSAGE, MISSING_API_KEY_MESSAGE, MISSING_DEVICE_ID_MESSAGE, STORAGE_FAILURE, UNEXPECTED_ERROR_MESSAGE, UNEXPECTED_NETWORK_ERROR_MESSAGE, getSuccessMessage, } from './messages';
-import { RecordingStatus, } from './typings/session-replay';
-import { VERSION } from './version';
+import { BLOCK_CLASS, DEFAULT_SESSION_REPLAY_PROPERTY, MASK_TEXT_CLASS, SESSION_REPLAY_DEBUG_PROPERTY, } from './constants';
+import { SessionReplayEventsManager } from './events-manager';
+import { generateHashCode, generateSessionReplayId, isSessionInSample, maskInputFn } from './helpers';
+import { SessionIdentifiers } from './identifiers';
 var SessionReplay = /** @class */ (function () {
     function SessionReplay() {
         var _this = this;
         this.name = '@amplitude/session-replay-browser';
-        this.storageKey = '';
-        this.retryTimeout = 1000;
-        this.events = [];
-        this.currentSequenceId = 0;
-        this.scheduled = null;
-        this.queue = [];
         this.stopRecordingEvents = null;
-        this.maxPersistedEventsSize = MAX_EVENT_LIST_SIZE_IN_BYTES;
-        this.interval = MIN_INTERVAL;
-        this.timeAtLastSend = null;
         this.blurListener = function () {
             _this.stopRecordingAndSendEvents();
         };
         this.focusListener = function () {
             void _this.initialize();
         };
-        /**
-         * Determines whether to send the events list to the backend and start a new
-         * empty events list, based on the size of the list as well as the last time sent
-         * @param nextEventString
-         * @returns boolean
-         */
-        this.shouldSplitEventsList = function (nextEventString) {
-            var sizeOfNextEvent = new Blob([nextEventString]).size;
-            var sizeOfEventsList = new Blob(_this.events).size;
-            if (sizeOfEventsList + sizeOfNextEvent >= _this.maxPersistedEventsSize) {
-                return true;
-            }
-            if (_this.timeAtLastSend !== null && Date.now() - _this.timeAtLastSend > _this.interval && _this.events.length) {
-                _this.interval = Math.min(MAX_INTERVAL, _this.interval + MIN_INTERVAL);
-                _this.timeAtLastSend = Date.now();
-                return true;
-            }
-            return false;
-        };
         this.loggerProvider = new Logger();
     }
     SessionReplay.prototype.init = function (apiKey, options) {
@@ -62,8 +31,11 @@ var SessionReplay = /** @class */ (function () {
                     case 0:
                         this.config = new SessionReplayConfig(apiKey, options);
                         this.loggerProvider = this.config.loggerProvider;
+                        this.identifiers = new SessionIdentifiers(options, this.loggerProvider);
+                        this.eventsManager = new SessionReplayEventsManager({
+                            config: this.config,
+                        });
                         this.loggerProvider.log('Installing @amplitude/session-replay-browser.');
-                        this.storageKey = "".concat(STORAGE_PREFIX, "_").concat(this.config.apiKey.substring(0, 10));
                         globalScope = getGlobalScope();
                         if (globalScope) {
                             globalScope.addEventListener('blur', this.blurListener);
@@ -80,26 +52,25 @@ var SessionReplay = /** @class */ (function () {
         });
     };
     SessionReplay.prototype.setSessionId = function (sessionId, deviceId) {
-        if (!this.config) {
+        if (!this.identifiers) {
             this.loggerProvider.error('Session replay init has not been called, cannot set session id.');
             return;
         }
         if (deviceId) {
-            this.config.deviceId = deviceId;
+            this.identifiers.deviceId = deviceId;
         }
         // use a consistent device id.
         var deviceIdForReplayId = this.getDeviceId();
         if (sessionId && deviceIdForReplayId) {
-            this.config.sessionReplayId = generateSessionReplayId(sessionId, deviceIdForReplayId);
+            this.identifiers.sessionReplayId = generateSessionReplayId(sessionId, deviceIdForReplayId);
         }
         else {
             this.loggerProvider.error('Must provide either session replay id or session id when starting a new session.');
             return;
         }
-        this.stopRecordingAndSendEvents(this.config.sessionId);
-        this.config.sessionId = sessionId;
-        this.events = [];
-        this.currentSequenceId = 0;
+        this.stopRecordingAndSendEvents(this.identifiers.sessionId);
+        this.identifiers.sessionId = sessionId;
+        this.eventsManager && this.eventsManager.resetSequence();
         this.recordEvents();
     };
     SessionReplay.prototype.getSessionReplayDebugPropertyValue = function () {
@@ -113,7 +84,7 @@ var SessionReplay = /** @class */ (function () {
     };
     SessionReplay.prototype.getSessionReplayProperties = function () {
         var _a;
-        if (!this.config) {
+        if (!this.config || !this.identifiers) {
             this.loggerProvider.error('Session replay init has not been called, cannot get session recording properties.');
             return {};
         }
@@ -123,7 +94,7 @@ var SessionReplay = /** @class */ (function () {
         var shouldRecord = this.getShouldRecord(ignoreFocus);
         if (shouldRecord) {
             var eventProperties = (_a = {},
-                _a[DEFAULT_SESSION_REPLAY_PROPERTY] = this.config.sessionReplayId ? this.config.sessionReplayId : null,
+                _a[DEFAULT_SESSION_REPLAY_PROPERTY] = this.identifiers.sessionReplayId ? this.identifiers.sessionReplayId : null,
                 _a);
             if (this.config.debugMode) {
                 eventProperties[SESSION_REPLAY_DEBUG_PROPERTY] = this.getSessionReplayDebugPropertyValue();
@@ -142,54 +113,39 @@ var SessionReplay = /** @class */ (function () {
             var typedError = error;
             this.loggerProvider.warn("Error occurred while stopping recording: ".concat(typedError.toString()));
         }
-        var sessionIdToSend = sessionId || ((_a = this.config) === null || _a === void 0 ? void 0 : _a.sessionId);
-        if (this.events.length && sessionIdToSend) {
-            this.sendEventsList({
-                events: this.events,
-                sequenceId: this.currentSequenceId,
-                sessionId: sessionIdToSend,
-            });
-        }
+        var sessionIdToSend = sessionId || ((_a = this.identifiers) === null || _a === void 0 ? void 0 : _a.sessionId);
+        var deviceId = this.getDeviceId();
+        this.eventsManager &&
+            sessionIdToSend &&
+            deviceId &&
+            this.eventsManager.sendEvents({ sessionId: sessionIdToSend, deviceId: deviceId });
     };
     SessionReplay.prototype.initialize = function (shouldSendStoredEvents) {
         var _a;
         if (shouldSendStoredEvents === void 0) { shouldSendStoredEvents = false; }
         return __awaiter(this, void 0, void 0, function () {
-            var storedReplaySessions, storedSequencesForSession, storedSeqId, lastSequence;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var deviceId, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        this.timeAtLastSend = Date.now(); // Initialize this so we have a point of comparison when events are recorded
-                        if (!((_a = this.config) === null || _a === void 0 ? void 0 : _a.sessionId)) {
+                        if (!((_a = this.identifiers) === null || _a === void 0 ? void 0 : _a.sessionId)) {
                             this.loggerProvider.warn("Session is not being recorded due to lack of session id.");
                             return [2 /*return*/];
                         }
-                        return [4 /*yield*/, this.getAllSessionEventsFromStore()];
+                        deviceId = this.getDeviceId();
+                        _b = this.eventsManager &&
+                            deviceId;
+                        if (!_b) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.eventsManager.initialize({
+                                sessionId: this.identifiers.sessionId,
+                                shouldSendStoredEvents: shouldSendStoredEvents,
+                                deviceId: deviceId,
+                            })];
                     case 1:
-                        storedReplaySessions = _b.sent();
-                        // This resolves a timing issue when focus is fired multiple times in short succession,
-                        // we only want the rest of this function to run once. We can be sure that initialize has
-                        // already been called if this.stopRecordingEvents is defined
-                        if (this.stopRecordingEvents) {
-                            return [2 /*return*/];
-                        }
-                        storedSequencesForSession = storedReplaySessions && storedReplaySessions[this.config.sessionId];
-                        if (storedReplaySessions && storedSequencesForSession && storedSequencesForSession.sessionSequences) {
-                            storedSeqId = storedSequencesForSession.currentSequenceId;
-                            lastSequence = storedSequencesForSession.sessionSequences[storedSeqId];
-                            if (lastSequence && lastSequence.status !== RecordingStatus.RECORDING) {
-                                this.currentSequenceId = storedSeqId + 1;
-                                this.events = [];
-                            }
-                            else {
-                                // Pick up recording where it was left off in another tab or window
-                                this.currentSequenceId = storedSeqId;
-                                this.events = (lastSequence === null || lastSequence === void 0 ? void 0 : lastSequence.events) || [];
-                            }
-                        }
-                        if (shouldSendStoredEvents && storedReplaySessions) {
-                            this.sendStoredEvents(storedReplaySessions);
-                        }
+                        _b = (_c.sent());
+                        _c.label = 2;
+                    case 2:
+                        _b;
                         this.recordEvents();
                         return [2 /*return*/];
                 }
@@ -207,30 +163,30 @@ var SessionReplay = /** @class */ (function () {
     };
     SessionReplay.prototype.getShouldRecord = function (ignoreFocus) {
         if (ignoreFocus === void 0) { ignoreFocus = false; }
-        if (!this.config) {
+        if (!this.identifiers || !this.config) {
             this.loggerProvider.error("Session is not being recorded due to lack of config, please call sessionReplay.init.");
             return false;
         }
         var globalScope = getGlobalScope();
         if (!ignoreFocus && globalScope && globalScope.document && !globalScope.document.hasFocus()) {
-            if (this.config.sessionId) {
-                this.loggerProvider.log("Session ".concat(this.config.sessionId, " temporarily not recording due to lack of browser focus."));
+            if (this.identifiers.sessionId) {
+                this.loggerProvider.log("Session ".concat(this.identifiers.sessionId, " temporarily not recording due to lack of browser focus."));
             }
             return false;
         }
         else if (this.shouldOptOut()) {
-            if (this.config.sessionId) {
-                this.loggerProvider.log("Opting session ".concat(this.config.sessionId, " out of recording due to optOut config."));
+            if (this.identifiers.sessionId) {
+                this.loggerProvider.log("Opting session ".concat(this.identifiers.sessionId, " out of recording due to optOut config."));
             }
             return false;
         }
-        else if (!this.config.sessionId) {
+        else if (!this.identifiers.sessionId) {
             this.loggerProvider.warn("Session is not being recorded due to lack of session id.");
             return false;
         }
-        var isInSample = isSessionInSample(this.config.sessionId, this.getSampleRate());
+        var isInSample = isSessionInSample(this.identifiers.sessionId, this.config.sampleRate);
         if (!isInSample) {
-            this.loggerProvider.log("Opting session ".concat(this.config.sessionId, " out of recording due to sample rate."));
+            this.loggerProvider.log("Opting session ".concat(this.identifiers.sessionId, " out of recording due to sample rate."));
         }
         return isInSample;
     };
@@ -238,32 +194,11 @@ var SessionReplay = /** @class */ (function () {
         var _a, _b;
         return (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.privacyConfig) === null || _b === void 0 ? void 0 : _b.blockSelector;
     };
-    SessionReplay.prototype.sendStoredEvents = function (storedReplaySessions) {
-        var _a;
-        for (var sessionId in storedReplaySessions) {
-            var storedSequences = storedReplaySessions[sessionId].sessionSequences;
-            for (var storedSeqId in storedSequences) {
-                var seq = storedSequences[storedSeqId];
-                var numericSeqId = parseInt(storedSeqId, 10);
-                var numericSessionId = parseInt(sessionId, 10);
-                if (numericSessionId === ((_a = this.config) === null || _a === void 0 ? void 0 : _a.sessionId) && numericSeqId === this.currentSequenceId) {
-                    continue;
-                }
-                if (seq.events && seq.events.length && seq.status === RecordingStatus.RECORDING) {
-                    this.sendEventsList({
-                        events: seq.events,
-                        sequenceId: numericSeqId,
-                        sessionId: numericSessionId,
-                    });
-                }
-            }
-        }
-    };
     SessionReplay.prototype.recordEvents = function () {
         var _this = this;
         var _a;
         var shouldRecord = this.getShouldRecord();
-        var sessionId = (_a = this.config) === null || _a === void 0 ? void 0 : _a.sessionId;
+        var sessionId = (_a = this.identifiers) === null || _a === void 0 ? void 0 : _a.sessionId;
         if (!shouldRecord || !sessionId) {
             return;
         }
@@ -275,18 +210,8 @@ var SessionReplay = /** @class */ (function () {
                     return;
                 }
                 var eventString = JSON.stringify(event);
-                var shouldSplit = _this.shouldSplitEventsList(eventString);
-                if (shouldSplit) {
-                    _this.sendEventsList({
-                        events: _this.events,
-                        sequenceId: _this.currentSequenceId,
-                        sessionId: sessionId,
-                    });
-                    _this.events = [];
-                    _this.currentSequenceId++;
-                }
-                _this.events.push(eventString);
-                void _this.storeEventsForSession(_this.events, _this.currentSequenceId, sessionId);
+                var deviceId = _this.getDeviceId();
+                deviceId && _this.eventsManager && _this.eventsManager.addEvent({ event: eventString, sessionId: sessionId, deviceId: deviceId });
             },
             packFn: pack,
             maskAllInputs: true,
@@ -303,96 +228,6 @@ var SessionReplay = /** @class */ (function () {
             },
         });
     };
-    SessionReplay.prototype.sendEventsList = function (_a) {
-        var events = _a.events, sequenceId = _a.sequenceId, sessionId = _a.sessionId;
-        this.addToQueue({
-            events: events,
-            sequenceId: sequenceId,
-            attempts: 0,
-            timeout: 0,
-            sessionId: sessionId,
-        });
-    };
-    SessionReplay.prototype.addToQueue = function () {
-        var _this = this;
-        var list = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            list[_i] = arguments[_i];
-        }
-        var tryable = list.filter(function (context) {
-            var _a;
-            if (context.attempts < (((_a = _this.config) === null || _a === void 0 ? void 0 : _a.flushMaxRetries) || 0)) {
-                context.attempts += 1;
-                return true;
-            }
-            _this.completeRequest({
-                context: context,
-                err: "".concat(MAX_RETRIES_EXCEEDED_MESSAGE, ", batch sequence id, ").concat(context.sequenceId),
-            });
-            return false;
-        });
-        tryable.forEach(function (context) {
-            _this.queue = _this.queue.concat(context);
-            if (context.timeout === 0) {
-                _this.schedule(0);
-                return;
-            }
-            setTimeout(function () {
-                context.timeout = 0;
-                _this.schedule(0);
-            }, context.timeout);
-        });
-    };
-    SessionReplay.prototype.schedule = function (timeout) {
-        var _this = this;
-        if (this.scheduled)
-            return;
-        this.scheduled = setTimeout(function () {
-            void _this.flush(true).then(function () {
-                if (_this.queue.length > 0) {
-                    _this.schedule(timeout);
-                }
-            });
-        }, timeout);
-    };
-    SessionReplay.prototype.flush = function (useRetry) {
-        if (useRetry === void 0) { useRetry = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var list, later;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        list = [];
-                        later = [];
-                        this.queue.forEach(function (context) { return (context.timeout === 0 ? list.push(context) : later.push(context)); });
-                        this.queue = later;
-                        if (this.scheduled) {
-                            clearTimeout(this.scheduled);
-                            this.scheduled = null;
-                        }
-                        return [4 /*yield*/, Promise.all(list.map(function (context) { return _this.send(context, useRetry); }))];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SessionReplay.prototype.getSampleRate = function () {
-        var _a;
-        return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.sampleRate) || DEFAULT_SAMPLE_RATE;
-    };
-    SessionReplay.prototype.getServerUrl = function () {
-        var _a, _b;
-        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.serverZone) === ServerZone.STAGING) {
-            return SESSION_REPLAY_STAGING_SERVER_URL;
-        }
-        if (((_b = this.config) === null || _b === void 0 ? void 0 : _b.serverZone) === ServerZone.EU) {
-            return SESSION_REPLAY_EU_SERVER_URL;
-        }
-        return SESSION_REPLAY_SERVER_URL;
-    };
     SessionReplay.prototype.getDeviceId = function () {
         var _a, _b;
         var identityStoreDeviceId;
@@ -400,209 +235,23 @@ var SessionReplay = /** @class */ (function () {
             var identityStore = getAnalyticsConnector(this.config.instanceName).identityStore;
             identityStoreDeviceId = identityStore.getIdentity().deviceId;
         }
-        return identityStoreDeviceId || ((_b = this.config) === null || _b === void 0 ? void 0 : _b.deviceId);
+        return identityStoreDeviceId || ((_b = this.identifiers) === null || _b === void 0 ? void 0 : _b.deviceId);
     };
     SessionReplay.prototype.getSessionId = function () {
         var _a;
-        return (_a = this.config) === null || _a === void 0 ? void 0 : _a.sessionId;
+        return (_a = this.identifiers) === null || _a === void 0 ? void 0 : _a.sessionId;
     };
-    SessionReplay.prototype.send = function (context, useRetry) {
-        var _a;
-        if (useRetry === void 0) { useRetry = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            var apiKey, deviceId, url, version, sampleRate, urlParams, payload, options, server_url, res, responseBody, e_1;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        apiKey = (_a = this.config) === null || _a === void 0 ? void 0 : _a.apiKey;
-                        if (!apiKey) {
-                            return [2 /*return*/, this.completeRequest({ context: context, err: MISSING_API_KEY_MESSAGE })];
-                        }
-                        deviceId = this.getDeviceId();
-                        if (!deviceId) {
-                            return [2 /*return*/, this.completeRequest({ context: context, err: MISSING_DEVICE_ID_MESSAGE })];
-                        }
-                        url = getCurrentUrl();
-                        version = VERSION;
-                        sampleRate = this.getSampleRate();
-                        urlParams = new URLSearchParams({
-                            device_id: deviceId,
-                            session_id: "".concat(context.sessionId),
-                            seq_number: "".concat(context.sequenceId),
-                        });
-                        payload = {
-                            version: 1,
-                            events: context.events,
-                        };
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 3, , 4]);
-                        options = {
-                            headers: {
-                                'Content-Type': 'application/json',
-                                Accept: '*/*',
-                                Authorization: "Bearer ".concat(apiKey),
-                                'X-Client-Version': version,
-                                'X-Client-Url': url,
-                                'X-Client-Sample-Rate': "".concat(sampleRate),
-                            },
-                            body: JSON.stringify(payload),
-                            method: 'POST',
-                        };
-                        server_url = "".concat(this.getServerUrl(), "?").concat(urlParams.toString());
-                        return [4 /*yield*/, fetch(server_url, options)];
-                    case 2:
-                        res = _b.sent();
-                        if (res === null) {
-                            this.completeRequest({ context: context, err: UNEXPECTED_ERROR_MESSAGE });
-                            return [2 /*return*/];
-                        }
-                        if (!useRetry) {
-                            responseBody = '';
-                            try {
-                                responseBody = JSON.stringify(res.body, null, 2);
-                            }
-                            catch (_c) {
-                                // to avoid crash, but don't care about the error, add comment to avoid empty block lint error
-                            }
-                            this.completeRequest({ context: context, success: "".concat(res.status, ": ").concat(responseBody) });
-                        }
-                        else {
-                            this.handleReponse(res.status, context);
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        e_1 = _b.sent();
-                        this.completeRequest({ context: context, err: e_1 });
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SessionReplay.prototype.handleReponse = function (status, context) {
-        var parsedStatus = new BaseTransport().buildStatus(status);
-        switch (parsedStatus) {
-            case Status.Success:
-                this.handleSuccessResponse(context);
-                break;
-            case Status.Failed:
-                this.handleOtherResponse(context);
-                break;
-            default:
-                this.completeRequest({ context: context, err: UNEXPECTED_NETWORK_ERROR_MESSAGE });
-        }
-    };
-    SessionReplay.prototype.handleSuccessResponse = function (context) {
-        this.completeRequest({ context: context, success: getSuccessMessage(context.sessionId) });
-    };
-    SessionReplay.prototype.handleOtherResponse = function (context) {
-        this.addToQueue(__assign(__assign({}, context), { timeout: context.attempts * this.retryTimeout }));
-    };
-    SessionReplay.prototype.getAllSessionEventsFromStore = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var storedReplaySessionContexts, e_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, IDBKeyVal.get(this.storageKey)];
-                    case 1:
-                        storedReplaySessionContexts = _a.sent();
-                        return [2 /*return*/, storedReplaySessionContexts];
-                    case 2:
-                        e_2 = _a.sent();
-                        this.loggerProvider.warn("".concat(STORAGE_FAILURE, ": ").concat(e_2));
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/, undefined];
-                }
-            });
-        });
-    };
-    SessionReplay.prototype.storeEventsForSession = function (events, sequenceId, sessionId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var e_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, IDBKeyVal.update(this.storageKey, function (sessionMap) {
-                                var _a, _b;
-                                if (sessionMap === void 0) { sessionMap = {}; }
-                                var session = sessionMap[sessionId] || __assign({}, defaultSessionStore);
-                                session.currentSequenceId = sequenceId;
-                                var currentSequence = (session.sessionSequences && session.sessionSequences[sequenceId]) || {};
-                                currentSequence.events = events;
-                                currentSequence.status = RecordingStatus.RECORDING;
-                                return __assign(__assign({}, sessionMap), (_a = {}, _a[sessionId] = __assign(__assign({}, session), { sessionSequences: __assign(__assign({}, session.sessionSequences), (_b = {}, _b[sequenceId] = currentSequence, _b)) }), _a));
-                            })];
-                    case 1:
-                        _a.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        e_3 = _a.sent();
-                        this.loggerProvider.warn("".concat(STORAGE_FAILURE, ": ").concat(e_3));
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SessionReplay.prototype.cleanUpSessionEventsStore = function (sessionId, sequenceId) {
+    SessionReplay.prototype.flush = function (useRetry) {
+        if (useRetry === void 0) { useRetry = false; }
         return __awaiter(this, void 0, void 0, function () {
-            var e_4;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, IDBKeyVal.update(this.storageKey, function (sessionMap) {
-                                if (sessionMap === void 0) { sessionMap = {}; }
-                                var session = sessionMap[sessionId];
-                                var sequenceToUpdate = (session === null || session === void 0 ? void 0 : session.sessionSequences) && session.sessionSequences[sequenceId];
-                                if (!sequenceToUpdate) {
-                                    return sessionMap;
-                                }
-                                sequenceToUpdate.events = [];
-                                sequenceToUpdate.status = RecordingStatus.SENT;
-                                // Delete sent sequences for current session
-                                Object.entries(session.sessionSequences).forEach(function (_a) {
-                                    var _b = __read(_a, 2), storedSeqId = _b[0], sequence = _b[1];
-                                    var numericStoredSeqId = parseInt(storedSeqId, 10);
-                                    if (sequence.status === RecordingStatus.SENT && sequenceId !== numericStoredSeqId) {
-                                        delete session.sessionSequences[numericStoredSeqId];
-                                    }
-                                });
-                                // Delete any sessions that are older than 3 days
-                                Object.keys(sessionMap).forEach(function (sessionId) {
-                                    var numericSessionId = parseInt(sessionId, 10);
-                                    if (Date.now() - numericSessionId >= MAX_IDB_STORAGE_LENGTH) {
-                                        delete sessionMap[numericSessionId];
-                                    }
-                                });
-                                return sessionMap;
-                            })];
-                    case 1:
-                        _a.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        e_4 = _a.sent();
-                        this.loggerProvider.warn("".concat(STORAGE_FAILURE, ": ").concat(e_4));
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+                if (this.eventsManager) {
+                    return [2 /*return*/, this.eventsManager.flush(useRetry)];
                 }
+                return [2 /*return*/];
             });
         });
     };
-    SessionReplay.prototype.completeRequest = function (_a) {
-        var context = _a.context, err = _a.err, success = _a.success;
-        context.sessionId && this.cleanUpSessionEventsStore(context.sessionId, context.sequenceId);
-        if (err) {
-            this.loggerProvider.warn(err);
-        }
-        else if (success) {
-            this.loggerProvider.log(success);
-        }
-    };
     SessionReplay.prototype.shutdown = function () {
         var globalScope = getGlobalScope();
         if (globalScope) {