feat(replay): account for V2 trigger groups

Author: ksvat

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

@@ -4142,4 +4142,193 @@ describe('Lazy SessionRecording', () => {
             expect(posthog.capture).toHaveBeenCalled()
         })
     })
+
+    describe('V2 Trigger Groups Integration', () => {
+        it('registers session properties when trigger group matches and is sampled', () => {
+            const registerSpy = jest.spyOn(posthog, 'register_for_session')
+
+            sessionRecording.onRemoteConfig(
+                makeFlagsResponse({
+                    sessionRecording: {
+                        endpoint: '/s/',
+                        version: 2,
+                        triggerGroups: [
+                            {
+                                id: 'error-group',
+                                name: 'Error Tracking',
+                                sampleRate: 1.0,
+                                conditions: {
+                                    matchType: 'any',
+                                    events: ['$exception'],
+                                },
+                            },
+                        ],
+                    },
+                })
+            )
+
+            expect(sessionRecording.status).toBe('buffering')
+
+            // Trigger the event
+            simpleEventEmitter.emit('eventCaptured', { event: '$exception' })
+
+            // Should transition to sampled
+            expect(sessionRecording.status).toBe('sampled')
+
+            // Verify session properties were registered
+            expect(registerSpy).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    $sdk_debug_replay_matched_recording_trigger_groups: expect.arrayContaining([
+                        expect.objectContaining({
+                            id: 'error-group',
+                            name: 'Error Tracking',
+                            matched: true,
+                            sampled: true,
+                        }),
+                    ]),
+                })
+            )
+        })
+
+        it('respects URL blocklist even when trigger group matches', () => {
+            sessionRecording.onRemoteConfig(
+                makeFlagsResponse({
+                    sessionRecording: {
+                        endpoint: '/s/',
+                        version: 2,
+                        triggerGroups: [
+                            {
+                                id: 'all-events',
+                                name: 'All Events',
+                                sampleRate: 1.0,
+                                conditions: {
+                                    matchType: 'any',
+                                    events: ['$pageview'],
+                                },
+                            },
+                        ],
+                        urlBlocklist: [
+                            {
+                                matching: 'regex',
+                                url: '/admin',
+                            },
+                        ],
+                    },
+                })
+            )
+
+            expect(sessionRecording.status).toBe('buffering')
+
+            // Navigate to blocked URL
+            fakeNavigateTo('https://test.com/admin')
+            _emit(createIncrementalSnapshot({ data: { source: 1 } }))
+
+            // Trigger event on blocked URL
+            simpleEventEmitter.emit('eventCaptured', { event: '$pageview' })
+
+            // Should be PAUSED, not SAMPLED (blocklist takes priority)
+            expect(sessionRecording.status).toBe('paused')
+        })
+
+        it('tracks multiple trigger groups with union behavior', () => {
+            const registerSpy = jest.spyOn(posthog, 'register_for_session')
+
+            sessionRecording.onRemoteConfig(
+                makeFlagsResponse({
+                    sessionRecording: {
+                        endpoint: '/s/',
+                        version: 2,
+                        triggerGroups: [
+                            {
+                                id: 'errors',
+                                name: 'Error Tracking',
+                                sampleRate: 1.0,
+                                conditions: {
+                                    matchType: 'any',
+                                    events: ['$exception'],
+                                },
+                            },
+                            {
+                                id: 'pageviews',
+                                name: 'Pageview Tracking',
+                                sampleRate: 1.0,
+                                conditions: {
+                                    matchType: 'any',
+                                    events: ['$pageview'],
+                                },
+                            },
+                        ],
+                    },
+                })
+            )
+
+            // Trigger both groups
+            simpleEventEmitter.emit('eventCaptured', { event: '$exception' })
+            simpleEventEmitter.emit('eventCaptured', { event: '$pageview' })
+
+            expect(sessionRecording.status).toBe('sampled')
+
+            // Should track both groups
+            expect(registerSpy).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    $sdk_debug_replay_matched_recording_trigger_groups: expect.arrayContaining([
+                        expect.objectContaining({ id: 'errors', sampled: true }),
+                        expect.objectContaining({ id: 'pageviews', sampled: true }),
+                    ]),
+                })
+            )
+
+            // Find the call with the trigger groups property
+            const callsWithProperty = registerSpy.mock.calls.filter(
+                (call) => call[0].$sdk_debug_replay_matched_recording_trigger_groups
+            )
+            expect(callsWithProperty.length).toBeGreaterThan(0)
+            const groups = callsWithProperty[callsWithProperty.length - 1][0]
+                .$sdk_debug_replay_matched_recording_trigger_groups
+            expect(groups).toHaveLength(2)
+        })
+
+        it('triggers immediately when trigger group has empty conditions', () => {
+            const registerSpy = jest.spyOn(posthog, 'register_for_session')
+
+            sessionRecording.onRemoteConfig(
+                makeFlagsResponse({
+                    sessionRecording: {
+                        endpoint: '/s/',
+                        version: 2,
+                        triggerGroups: [
+                            {
+                                id: 'all-sessions',
+                                name: 'All Sessions',
+                                sampleRate: 1.0,
+                                minDurationMs: 0,
+                                conditions: {
+                                    matchType: 'any',
+                                    // Empty conditions - no events, urls, or flags
+                                },
+                            },
+                        ],
+                    },
+                })
+            )
+
+            // Should immediately trigger without needing any events
+            // Status should be sampled (not buffering)
+            expect(sessionRecording.status).toBe('sampled')
+
+            // Verify session properties were registered
+            expect(registerSpy).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    $sdk_debug_replay_matched_recording_trigger_groups: expect.arrayContaining([
+                        expect.objectContaining({
+                            id: 'all-sessions',
+                            name: 'All Sessions',
+                            matched: true,
+                            sampled: true,
+                        }),
+                    ]),
+                })
+            )
+        })
+    })
 })