@multiplayer-app/session-recorder-browser 2.0.36 → 2.0.38

package/dist/index.umd.js

@@ -24436,7 +24436,7 @@ const CONTINUOUS_DEBUGGING_TIMEOUT = 60000; // 1 minutes
 const DEBUG_SESSION_MAX_DURATION_SECONDS = 10 * 60 + 30; // TODO: move to shared config otel core
 const REMOTE_SESSION_RECORDING_START = 'remote-session-recording:start';
 const REMOTE_SESSION_RECORDING_STOP = 'remote-session-recording:stop';
-const PACKAGE_VERSION_EXPORT = "2.0.36" || 0;
+const PACKAGE_VERSION_EXPORT = "2.0.38" || 0;
 // Regex patterns for OpenTelemetry ignore URLs
 const OTEL_IGNORE_URLS = [
     // Traces endpoint
@@ -26530,10 +26530,11 @@ class ApiService {
 
 
 class CrashBufferService {
-    constructor(db, tabId, windowMs) {
+    constructor(db, tabId, windowMs, ready = Promise.resolve()) {
         this.db = db;
         this.tabId = tabId;
         this.windowMs = windowMs;
+        this.ready = ready;
         this.lastPruneAt = 0;
         this.pruneInFlight = null;
         this.isActive = true;
@@ -26556,6 +26557,7 @@ class CrashBufferService {
         if (!this.isActive)
             return;
         const isFullSnapshot = Boolean(payload.isFullSnapshot);
+        await this.ready;
         await this._safe(async () => {
             await this.db.appendEvent({
                 tabId: this.tabId,
@@ -26576,6 +26578,7 @@ class CrashBufferService {
         if (!this.isActive)
             return;
         let errorEvent = null;
+        await this.ready;
         await this._safe(async () => {
             const records = payload.map((p) => {
                 var _a, _b;
@@ -26624,6 +26627,7 @@ class CrashBufferService {
     }
     async snapshot(_windowMs, now = Date.now()) {
         var _a, _b;
+        await this.ready;
         const stoppedAt = now;
         const startedAt = Math.max(0, stoppedAt - this.windowMs);
         // Always include a full snapshot "anchor" if one exists at/before the window start.
@@ -27261,6 +27265,8 @@ class SocketService extends lib0_observable__WEBPACK_IMPORTED_MODULE_4__.Observa
         this.sessionId = null;
         this.usePostMessage = false;
         this.isInitialized = false;
+        this.lastUserPayload = null;
+        this.lastSubscribeSession = null;
         this.options = {
             apiKey: '',
             socketUrl: '',
@@ -27323,6 +27329,15 @@ class SocketService extends lib0_observable__WEBPACK_IMPORTED_MODULE_4__.Observa
             this.isConnecting = false;
             this.isConnected = true;
             this.usePostMessage = false;
+            // Re-establish identity and session on every (re)connect: socket.io's auto-reconnect
+            // fires 'ready' again after a drop, but the server has no memory of the previous
+            // setUser/subscribe calls — the client must replay them.
+            if (this.lastUserPayload && this.socket) {
+                this.socket.emit(_config__WEBPACK_IMPORTED_MODULE_2__.SOCKET_SET_USER_EVENT, this.lastUserPayload);
+            }
+            if (this.lastSubscribeSession) {
+                this._emitSubscribe(this.lastSubscribeSession);
+            }
             this.flushQueue();
         });
         this.socket.on('disconnect', (err) => {
@@ -27389,16 +27404,33 @@ class SocketService extends lib0_observable__WEBPACK_IMPORTED_MODULE_4__.Observa
         this.emitSocketEvent(_config__WEBPACK_IMPORTED_MODULE_2__.SESSION_ADD_EVENT, event);
     }
     subscribeToSession(session) {
+        // Remember the session so reconnects replay subscribe + started.
+        this.lastSubscribeSession = session;
+        this._emitSubscribe(session);
+    }
+    _emitSubscribe(session) {
         this.sessionId = session.shortId || session._id;
-        const payload = {
+        const subscribePayload = {
             projectId: session.project,
             workspaceId: session.workspace,
             debugSessionId: this.sessionId,
             sessionType: session.creationType,
         };
-        this.emitSocketEvent(_config__WEBPACK_IMPORTED_MODULE_2__.SESSION_SUBSCRIBE_EVENT, payload);
-        // use long id instead of short id
-        this.emitSocketEvent(_config__WEBPACK_IMPORTED_MODULE_2__.SESSION_STARTED_EVENT, { debugSessionId: session._id });
+        const startedPayload = { debugSessionId: session._id };
+        // Send directly (not via the queue). The queue would cause a duplicate emit on
+        // the next 'ready' alongside the replay, since 'ready' also replays lastSubscribeSession.
+        if (this.usePostMessage) {
+            this.sendViaPostMessage(_config__WEBPACK_IMPORTED_MODULE_2__.SESSION_SUBSCRIBE_EVENT, subscribePayload);
+            this.sendViaPostMessage(_config__WEBPACK_IMPORTED_MODULE_2__.SESSION_STARTED_EVENT, startedPayload);
+        }
+        else if (this.socket && this.isConnected) {
+            this.socket.emit(_config__WEBPACK_IMPORTED_MODULE_2__.SESSION_SUBSCRIBE_EVENT, subscribePayload);
+            this.socket.emit(_config__WEBPACK_IMPORTED_MODULE_2__.SESSION_STARTED_EVENT, startedPayload);
+        }
+        else {
+            // Not connected: 'ready' will replay via lastSubscribeSession once the socket is up.
+            this._initConnection();
+        }
     }
     unsubscribeFromSession(stopSession) {
         if (this.sessionId) {
@@ -27407,9 +27439,23 @@ class SocketService extends lib0_observable__WEBPACK_IMPORTED_MODULE_4__.Observa
                 this.emitSocketEvent(_config__WEBPACK_IMPORTED_MODULE_2__.SESSION_STOPPED_EVENT, {});
             }
         }
+        this.lastSubscribeSession = null;
     }
     setUser(data) {
-        this.emitSocketEvent(_config__WEBPACK_IMPORTED_MODULE_2__.SOCKET_SET_USER_EVENT, data);
+        // Remember the last identity so 'ready' (initial connect + every reconnect) can replay it.
+        // Send directly here rather than queuing: the queue would cause a duplicate emit on the
+        // next 'ready' alongside the replay.
+        this.lastUserPayload = data;
+        if (this.usePostMessage) {
+            this.sendViaPostMessage(_config__WEBPACK_IMPORTED_MODULE_2__.SOCKET_SET_USER_EVENT, data);
+        }
+        else if (this.socket && this.isConnected) {
+            this.socket.emit(_config__WEBPACK_IMPORTED_MODULE_2__.SOCKET_SET_USER_EVENT, data);
+        }
+        else {
+            // Not connected yet: 'ready' will replay lastUserPayload once the socket is up.
+            this._initConnection();
+        }
     }
     close() {
         return new Promise((resolve) => {
@@ -27651,13 +27697,11 @@ class SessionRecorder extends lib0_observable__WEBPACK_IMPORTED_MODULE_16__.Obse
             this._start();
         }
         else {
-            // Buffer-only recording when there is no active debug session.
             this._startBufferOnlyRecording();
         }
         this._registerWidgetEvents();
         this._registerSocketServiceListeners();
         _services_messaging_service__WEBPACK_IMPORTED_MODULE_9__["default"].sendMessage('state-change', this.sessionState);
-        // Emit init observable event
         this.emit('init', [this]);
     }
     _setupCrashBuffer() {
@@ -27665,7 +27709,8 @@ class SessionRecorder extends lib0_observable__WEBPACK_IMPORTED_MODULE_16__.Obse
         if ((_a = this._configs.buffering) === null || _a === void 0 ? void 0 : _a.enabled) {
             const windowMinutes = this._configs.buffering.windowMinutes || 0.5;
             const windowMs = Math.max(10000, windowMinutes * 60 * 1000);
-            this._crashBuffer = new _services_crashBuffer_service__WEBPACK_IMPORTED_MODULE_13__.CrashBufferService(this._bufferDb, this._tabId, windowMs);
+            const ready = this._bufferDb.clearTab(this._tabId).catch(() => undefined);
+            this._crashBuffer = new _services_crashBuffer_service__WEBPACK_IMPORTED_MODULE_13__.CrashBufferService(this._bufferDb, this._tabId, windowMs, ready);
             this._recorder.setCrashBuffer(this._crashBuffer);
             this._tracer.setCrashBuffer(this._crashBuffer);
             this._crashBuffer.on('error-span-appended', (payload) => {
@@ -27899,12 +27944,7 @@ class SessionRecorder extends lib0_observable__WEBPACK_IMPORTED_MODULE_16__.Obse
         }
     }
     async _flushBuffer(sessionId) {
-        var _a, _b;
-        if (!sessionId ||
-            !this._crashBuffer ||
-            this._isFlushingBuffer ||
-            !((_b = (_a = this._configs) === null || _a === void 0 ? void 0 : _a.buffering) === null || _b === void 0 ? void 0 : _b.enabled) ||
-            this.sessionState !== _types__WEBPACK_IMPORTED_MODULE_4__.SessionState.stopped) {
+        if (!sessionId || !this._crashBuffer || this._isFlushingBuffer) {
             return null;
         }
         this._isFlushingBuffer = true;
@@ -28094,6 +28134,8 @@ class SessionRecorder extends lib0_observable__WEBPACK_IMPORTED_MODULE_16__.Obse
         });
         this._socketService.on(_config__WEBPACK_IMPORTED_MODULE_5__.SESSION_SAVE_BUFFER_EVENT, (payload) => {
             var _a;
+            if (this.sessionState !== _types__WEBPACK_IMPORTED_MODULE_4__.SessionState.stopped)
+                return;
             this._flushBuffer((_a = payload === null || payload === void 0 ? void 0 : payload.debugSession) === null || _a === void 0 ? void 0 : _a._id);
         });
     }