replay: wait for new config before recording decision

Author: Kim Dugan

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

@@ -374,5 +374,66 @@ 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()
+            // Note: _flushBuffer is always called from _onBeforeUnload, but returns early if buffering
+            expect(flushBufferSpy).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,12 @@ export class SessionRecording {
     }
 
     startIfEnabledOrStop(startReason?: SessionStartReason) {
+        // Wait for fresh remote config before starting recording
+        // This prevents using stale cached triggers from localStorage or CDN
+        if (!this._receivedFlags) {
+            return
+        }
+
         if (this._isRecordingEnabled && this._lazyLoadedSessionRecording?.isStarted) {
             return
         }