log trying to figure out why session start time is not being updated

Author: billyvg

packages/replay-internal/src/eventBuffer/EventBufferProxy.ts

@@ -115,6 +115,7 @@ export class EventBufferProxy implements EventBuffer {
     // Wait for original events to be re-added before resolving
     try {
       await Promise.all(addEventPromises);
+      DEBUG_BUILD && logger.info('Finished switching to compression worker');
 
       // Can now clear fallback buffer as it's no longer necessary
       this._fallback.clear();

packages/replay-internal/src/replay.ts

@@ -524,6 +524,7 @@ export class ReplayContainer implements ReplayContainerInterface {
     }
 
     const activityTime = Date.now();
+    const earliestEvent = this.eventBuffer && this.eventBuffer.getEarliestTimestamp();
 
     DEBUG_BUILD && logger.info('Converting buffer to session');
 
@@ -549,6 +550,9 @@ export class ReplayContainer implements ReplayContainerInterface {
 
     // Once this session ends, we do not want to refresh it
     if (this.session) {
+      if (earliestEvent) {
+        this.session.started = earliestEvent;
+      }
       this._updateUserActivity(activityTime);
       this._updateSessionActivity(activityTime);
       this._maybeSaveSession();
@@ -1222,35 +1226,14 @@ export class ReplayContainer implements ReplayContainerInterface {
       return;
     }
 
-    const start = this.session.started;
-    const now = Date.now();
-    const duration = now - start;
-
     // A flush is about to happen, cancel any queued flushes
     this._debouncedFlush.cancel();
 
-    // If session is too short, or too long (allow some wiggle room over maxReplayDuration), do not send it
-    // This _should_ not happen, but it may happen if flush is triggered due to a page activity change or similar
-    const tooShort = duration < this._options.minReplayDuration;
-    const tooLong = duration > this._options.maxReplayDuration + 5_000;
-    if (tooShort || tooLong) {
-      DEBUG_BUILD &&
-        logger.info(
-          `Session duration (${Math.floor(duration / 1000)}s) is too ${
-            tooShort ? 'short' : 'long'
-          }, not sending replay.`,
-        );
-
-      if (tooShort) {
-        this._debouncedFlush();
-      }
+    const isValidDuration = this._checkReplayDurationDuringFlush();
 
-      // XXX: disregard durations for buffer mode for debug purposes
-      if (this.recordingMode !== 'buffer') {
-        return;
-      } else {
-        setTag(`replay.${tooShort ? 'tooShort' : 'tooLong'}`, true);
-      }
+    // XXX: disregard durations for buffer mode for debug purposes
+    if (!isValidDuration && this.recordingMode !== 'buffer') {
+      return;
     }
 
     const eventBuffer = this.eventBuffer;
@@ -1285,6 +1268,52 @@ export class ReplayContainer implements ReplayContainerInterface {
     }
   };
 
+  /**
+   * Checks to see if replay duration is within bounds during a flush. If it is
+   * too short, will queue up a new flush to prevent short replays.
+   *
+   * Returns true if duration is ok, false otherwise
+   */
+  private _checkReplayDurationDuringFlush(): boolean {
+    if (!this.session) {
+      return false;
+    }
+
+    const earliestTimestampFromBuffer = this.eventBuffer && this.eventBuffer.getEarliestTimestamp();
+    const start =
+      this.recordingMode === 'buffer' && earliestTimestampFromBuffer
+        ? earliestTimestampFromBuffer
+        : this.session.started;
+    const now = Date.now();
+    const duration = now - start;
+
+    // If session is too short, or too long (allow some wiggle room over maxReplayDuration), do not send it
+    // This _should_ not happen, but it may happen if flush is triggered due to a page activity change or similar
+    const tooShort = duration < this._options.minReplayDuration;
+    const tooLong = duration > this._options.maxReplayDuration + 5_000;
+    if (tooShort || tooLong) {
+      DEBUG_BUILD &&
+        logger.info(
+          `Session duration (${Math.floor(duration / 1000)}s) is too ${
+            tooShort ? 'short' : 'long'
+          }, not sending replay.`,
+        );
+
+      if (tooShort) {
+        this._debouncedFlush();
+      }
+
+      // XXX: disregard durations for buffer mode for debug purposes
+      if (this.recordingMode === 'buffer') {
+        setTag(`replay.${tooShort ? 'tooShort' : 'tooLong'}`, true);
+      }
+
+      return false;
+    }
+
+    return true;
+  }
+
   /** Save the session, if it is sticky */
   private _maybeSaveSession(): void {
     if (this.session && this._options.stickySession) {

packages/replay-internal/src/util/handleRecordingEmit.ts

@@ -43,6 +43,7 @@ export function getHandleRecordingEmit(replay: ReplayContainer): RecordingEmitCa
       // dependent on this reset.
       if (replay.recordingMode === 'buffer' && isCheckout) {
         replay.setInitialState();
+        DEBUG_BUILD && logger.info('Adding checkout event while in buffer mode');
       }
 
       // If the event is not added (e.g. due to being paused, disabled, or out of the max replay duration),
@@ -83,8 +84,8 @@ export function getHandleRecordingEmit(replay: ReplayContainer): RecordingEmitCa
 
       // When in buffer mode, make sure we adjust the session started date to the current earliest event of the buffer
       // this should usually be the timestamp of the checkout event, but to be safe...
-      if (replay.recordingMode === 'buffer' && session && replay.eventBuffer) {
-        const earliestEvent = replay.eventBuffer.getEarliestTimestamp();
+      if (replay.recordingMode === 'buffer' && session) {
+        const earliestEvent = replay.eventBuffer && replay.eventBuffer.getEarliestTimestamp();
         if (earliestEvent) {
           DEBUG_BUILD &&
             logger.info(`Updating session start time to earliest event in buffer to ${new Date(earliestEvent)}`);
@@ -94,6 +95,9 @@ export function getHandleRecordingEmit(replay: ReplayContainer): RecordingEmitCa
           if (replay.getOptions().stickySession) {
             saveSession(session);
           }
+        } else {
+          // XXX(billy): debugging
+          DEBUG_BUILD && logger.warn('Unable to find earliest event in event buffer');
         }
       }