session recording: measure record_min_ms from first user event

The record_min_ms gate was previously anchored to the timestamp of the
first emitted rrweb event of any type. On a typical page load the first
event is a Meta or FullSnapshot fired before the user interacts, so a
session like "load page -> idle for 10s -> click once" would immediately
cross the threshold and start flushing a near-empty replay, producing a
sub-record_min_ms recording on the server.

Anchor _recordMinMsCheckStart to the first user-activity event instead,
which is the same notion of "recording duration" the player surfaces and
the customer is configuring against.

Updates an existing unit test whose timings encoded the old behavior and
adds a regression test for the idle-then-click case.

Author: elliotrfeinberg

src/recorder/session-recording.js

@@ -281,10 +281,14 @@ SessionRecording.prototype.startRecording = function (shouldStopBatcher) {
                     this._onIdleTimeout();
                     return;
                 }
-                if (this._recordMinMsCheckStart === null) {
-                    this._recordMinMsCheckStart = ev.timestamp;
-                }
                 if (isUserEvent(ev)) {
+                    // Measure record_min_ms from the first user event, not the first rrweb event.
+                    // Initial Meta/FullSnapshot/Mutation events fire at page load before any
+                    // interaction, so anchoring on them would let an idle-then-click flush a
+                    // near-empty replay (see MULTI-436).
+                    if (this._recordMinMsCheckStart === null) {
+                        this._recordMinMsCheckStart = ev.timestamp;
+                    }
                     if (this.batcher.stopped && ev.timestamp - this._recordMinMsCheckStart >= this.recordMinMs) {
                         this.batcher.start();
                     }

tests/unit/session-recording.js

@@ -685,12 +685,56 @@ describe(`SessionRecording`, function() {
       clock.tick(2000);
       expect(rec.batcher.stopped).to.be.true;
 
-      // user event before record_min_ms should not start the batcher
+      // user event before record_min_ms (measured from first user event) should not start the batcher
       mockRrweb.emit(EventType.IncrementalSnapshot, IncrementalSource.MouseInteraction);
       expect(rec.batcher.stopped).to.be.true;
 
-      // after record_min_ms, a user event should start the batcher
-      clock.tick(4000);
+      // after record_min_ms has elapsed since the first user event, the next user event starts the batcher
+      clock.tick(recordMinMs);
+      mockRrweb.emit(EventType.IncrementalSnapshot, IncrementalSource.MouseMove);
+      expect(rec.batcher.stopped).to.be.false;
+
+      rec.stopRecording();
+    });
+
+    it(`measures record_min_ms from first user event, not first rrweb event`, async function() {
+      // Regression test for MULTI-436: page loads, rrweb emits initial Meta/FullSnapshot,
+      // user is idle past record_min_ms, then clicks once. Previously this immediately
+      // started the batcher and flushed a near-empty replay because the threshold was
+      // measured from the initial snapshot rather than from the first user activity.
+      const recordMinMs = 8000;
+      const customMixpanel = new MockMixpanelLib({'record_min_ms': recordMinMs});
+
+      const rec = new SessionRecording({
+        mixpanelInstance: customMixpanel,
+        replayId: `min-ms-idle-load-replay`,
+        rrwebRecord: mockRrweb.recordStub,
+        sharedLockStorage: localStorage,
+      });
+
+      rec.startRecording();
+      expect(rec.batcher.stopped).to.be.true;
+
+      // initial non-user events at page load (t=0)
+      mockRrweb.emit(EventType.Meta);
+      mockRrweb.emit(EventType.FullSnapshot);
+
+      // user is idle for longer than record_min_ms, then interacts once
+      clock.tick(recordMinMs + 1000);
+      mockRrweb.emit(EventType.IncrementalSnapshot, IncrementalSource.MouseInteraction);
+
+      // batcher must NOT start: there has only been one user event so far,
+      // so the recorded user-activity window is 0ms, well below record_min_ms.
+      expect(rec.batcher.stopped).to.be.true;
+
+      // another user event still inside record_min_ms (measured from the first
+      // user event) must also keep the batcher stopped.
+      clock.tick(recordMinMs - 1);
+      mockRrweb.emit(EventType.IncrementalSnapshot, IncrementalSource.MouseMove);
+      expect(rec.batcher.stopped).to.be.true;
+
+      // one more tick crosses record_min_ms from the first user event; batcher starts.
+      clock.tick(2);
       mockRrweb.emit(EventType.IncrementalSnapshot, IncrementalSource.MouseMove);
       expect(rec.batcher.stopped).to.be.false;