replay: wait for new config before recording decision

Author: Kim Dugan

packages/browser/src/__tests__/extensions/replay/lazy-sessionrecording.test.ts

@@ -3819,49 +3819,16 @@ describe('Lazy SessionRecording', () => {
         })
     })
 
-    describe('stale config retry on script loaded', () => {
-        const FIVE_MINUTES_IN_MS = 5 * 60 * 1000
-
+    describe('wait for fresh config before starting', () => {
         beforeEach(() => {
             addRRwebToWindow()
         })
 
-        it('requests fresh config when persisted config is stale', () => {
-            posthog.persistence?.register({
-                [SESSION_RECORDING_REMOTE_CONFIG]: {
-                    enabled: true,
-                    endpoint: '/s/',
-                    cache_timestamp: Date.now() - FIVE_MINUTES_IN_MS - 1000,
-                },
-            })
-
-            sessionRecording.startIfEnabledOrStop()
-
-            expect(mockRemoteConfigLoad).toHaveBeenCalledTimes(1)
-            expect(sessionRecording.started).toBe(false)
-        })
-
-        it('does not request fresh config more than once', () => {
-            posthog.persistence?.register({
-                [SESSION_RECORDING_REMOTE_CONFIG]: {
-                    enabled: true,
-                    endpoint: '/s/',
-                    cache_timestamp: Date.now() - FIVE_MINUTES_IN_MS - 1000,
-                },
-            })
-
-            sessionRecording.startIfEnabledOrStop()
-            sessionRecording.startIfEnabledOrStop()
-
-            expect(mockRemoteConfigLoad).toHaveBeenCalledTimes(1)
-        })
-
-        it('starts recording after fresh config arrives', () => {
+        it('does not start recording until fresh config arrives', () => {
             posthog.persistence?.register({
                 [SESSION_RECORDING_REMOTE_CONFIG]: {
                     enabled: true,
                     endpoint: '/s/',
-                    cache_timestamp: Date.now() - FIVE_MINUTES_IN_MS - 1000,
                 },
             })
 

packages/browser/src/__tests__/extensions/replay/sessionRecording-onRemoteConfig.test.ts

@@ -374,5 +374,65 @@ describe('SessionRecording', () => {
             expect(posthog.get_property(SESSION_RECORDING_REMOTE_CONFIG).enabled).toBe(true)
             expect(sessionRecording['_lazyLoadedSessionRecording']['_endpoint']).toEqual('/ses/')
         })
+
+        it('does not start recording before remote config is received', () => {
+            // Set stale config in persistence (simulating cached/CDN config)
+            posthog.persistence?.register({
+                [SESSION_RECORDING_REMOTE_CONFIG]: {
+                    enabled: true,
+                    endpoint: '/s/',
+                    urlTriggers: [],
+                },
+            })
+
+            // Try to start without receiving remote config
+            sessionRecording.startIfEnabledOrStop()
+
+            // Should not have started recording yet
+            expect(loadScriptMock).not.toHaveBeenCalled()
+            expect(sessionRecording.status).toBe('lazy_loading')
+
+            // Now receive remote config
+            sessionRecording.onRemoteConfig(
+                makeFlagsResponse({
+                    sessionRecording: { endpoint: '/s/' },
+                })
+            )
+
+            // Should now start
+            expect(loadScriptMock).toHaveBeenCalled()
+            expect(sessionRecording.status).toBe('active')
+        })
+
+        it('discards buffer on beforeunload if remote config not yet loaded', () => {
+            // Set persistence to simulate config exists
+            posthog.persistence?.register({
+                [SESSION_RECORDING_REMOTE_CONFIG]: {
+                    enabled: true,
+                    endpoint: '/s/',
+                },
+            })
+
+            // Receive config to start recording
+            sessionRecording.onRemoteConfig(
+                makeFlagsResponse({
+                    sessionRecording: { endpoint: '/s/', urlTriggers: [{ url: 'example.com', matching: 'regex' }] },
+                })
+            )
+
+            // Should be buffering (waiting for trigger)
+            expect(sessionRecording.status).toBe('buffering')
+
+            const lazyRecorder = sessionRecording['_lazyLoadedSessionRecording']
+            const clearBufferSpy = jest.spyOn(lazyRecorder as any, '_clearBuffer')
+            const flushBufferSpy = jest.spyOn(lazyRecorder as any, '_flushBuffer')
+
+            // Trigger beforeunload
+            window.dispatchEvent(new Event('beforeunload'))
+
+            // Should have cleared buffer, not flushed it
+            expect(clearBufferSpy).toHaveBeenCalled()
+            expect(flushBufferSpy).not.toHaveBeenCalled()
+        })
     })
 })

packages/browser/src/extensions/replay/external/lazy-loaded-session-recorder.ts

@@ -1334,6 +1334,13 @@ export class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInt
     }
 
     private _onBeforeUnload = (): void => {
+        // If still buffering (waiting for remote config), discard the buffer
+        // Better to lose this data than record incorrectly.
+        if (this.status === BUFFERING) {
+            this._clearBuffer()
+            return
+        }
+
         this._flushBuffer()
     }
 

packages/browser/src/extensions/replay/session-recording.ts

@@ -73,6 +73,11 @@ export class SessionRecording {
     }
 
     startIfEnabledOrStop(startReason?: SessionStartReason) {
+        // Wait for fresh remote config before starting recording
+        if (!this._receivedFlags) {
+            return
+        }
+
         if (this._isRecordingEnabled && this._lazyLoadedSessionRecording?.isStarted) {
             return
         }