feat(replay): account for V2 trigger groups

Author: ksvat

packages/browser/src/__tests__/extensions/replay/triggerGroups-tracking.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Tests for tracking which trigger groups caused recording to start
+ */
+
+import { SessionRecordingTriggerGroup } from '../../../types'
+
+describe('Trigger Group Tracking', () => {
+    describe('Session Properties', () => {
+        it('should include properties showing which trigger groups caused recording', () => {
+            // This test documents the expected session properties that will be set
+            // Only groups that BOTH matched AND were sampled are included
+
+            const expectedSessionProperties = {
+                // Properties available to all users for analytics
+                $sdk_debug_replay_recording_trigger_groups: [
+                    {
+                        id: 'error-tracking',
+                        name: 'Error Tracking',
+                        matched: true, // Conditions were met
+                        sampled: true, // Sample rate hit
+                    },
+                ],
+                $sdk_debug_replay_recording_trigger_group_ids: ['error-tracking'],
+                $sdk_debug_replay_recording_trigger_group_names: ['Error Tracking'],
+            }
+
+            // These properties will be present on ALL events captured during the session
+            // Despite the $sdk_debug_ prefix, they're available to all users
+            expect(expectedSessionProperties).toBeDefined()
+        })
+
+        it('should handle multiple groups causing recording (union behavior)', () => {
+            const expectedSessionProperties = {
+                $sdk_debug_replay_recording_trigger_groups: [
+                    {
+                        id: 'errors',
+                        name: 'Error Tracking',
+                        matched: true,
+                        sampled: true,
+                    },
+                    {
+                        id: 'premium-users',
+                        name: 'Premium Users',
+                        matched: true,
+                        sampled: true,
+                    },
+                ],
+                $sdk_debug_replay_recording_trigger_group_ids: ['errors', 'premium-users'],
+                $sdk_debug_replay_recording_trigger_group_names: ['Error Tracking', 'Premium Users'],
+            }
+
+            // When multiple groups both match AND sample, ALL are tracked
+            expect(expectedSessionProperties.$sdk_debug_replay_recording_trigger_group_ids).toHaveLength(2)
+        })
+
+        it('should NOT include groups that matched but were sampled out', () => {
+            // Example: Group "low-priority" matched (conditions met) but sample rate missed (10% = 0.1)
+            // This group should NOT appear in the session properties because it didn't cause recording
+
+            const expectedSessionProperties = {
+                $sdk_debug_replay_recording_trigger_groups: [], // Empty - group didn't cause recording
+                $sdk_debug_replay_recording_trigger_group_ids: [],
+                $sdk_debug_replay_recording_trigger_group_names: [],
+            }
+
+            // Only groups that BOTH matched AND sampled are included
+            expect(expectedSessionProperties.$sdk_debug_replay_recording_trigger_groups).toHaveLength(0)
+        })
+    })
+
+    describe('Custom Events', () => {
+        it('should emit custom event when sampling decision is made for each group', () => {
+            const expectedCustomEvent = {
+                tag: 'triggerGroupSamplingDecisionMade',
+                payload: {
+                    group_id: 'error-tracking',
+                    group_name: 'Error Tracking',
+                    sampleRate: 1.0,
+                    isSampled: true,
+                },
+            }
+
+            // This custom event is added to the recording when sampling decisions are made
+            expect(expectedCustomEvent).toBeDefined()
+        })
+    })
+
+    describe('Analytics Use Cases', () => {
+        it('should enable filtering recordings by trigger group in analytics', () => {
+            // Example: Find all recordings caused by error tracking
+            const query = `
+                SELECT *
+                FROM recordings
+                WHERE 'error-tracking' IN $sdk_debug_replay_recording_trigger_group_ids
+            `
+
+            expect(query).toBeDefined()
+        })
+
+        it('should enable understanding trigger group effectiveness', () => {
+            // Example: Compare how many sessions each group triggers
+            const query = `
+                SELECT
+                    group_id,
+                    COUNT(*) as sessions_triggered
+                FROM recordings,
+                LATERAL VIEW EXPLODE($sdk_debug_replay_recording_trigger_group_ids) AS group_id
+                GROUP BY group_id
+            `
+
+            expect(query).toBeDefined()
+        })
+
+        it('should enable debugging why a session was recorded', () => {
+            // For any given recording, you can see exactly which trigger group(s) caused it
+            // If a group is in this array, it means:
+            // 1. Its conditions were met (matched)
+            // 2. Its sample rate hit (sampled)
+            // 3. It caused recording to start
+
+            const debugInfo = {
+                // Check if error tracking group caused this recording
+                wasErrorTracking: (groupIds: string[]) => groupIds.includes('error-tracking'),
+
+                // Get all trigger groups that caused recording
+                getAllCauses: (groups: Array<{ id: string; name: string }>) => groups.map((g) => g.name),
+            }
+
+            expect(debugInfo).toBeDefined()
+        })
+    })
+
+    describe('Type Definitions', () => {
+        it('should have proper TypeScript types for trigger groups', () => {
+            const group: SessionRecordingTriggerGroup = {
+                id: 'test-group',
+                name: 'Test Group',
+                sampleRate: 0.5,
+                minDurationMs: 1000,
+                conditions: {
+                    matchType: 'any',
+                    events: ['error'],
+                    urls: [{ url: '/checkout', matching: 'regex' }],
+                    flag: 'beta-users',
+                },
+            }
+
+            expect(group.id).toBe('test-group')
+            expect(group.sampleRate).toBe(0.5)
+            expect(group.conditions.matchType).toBe('any')
+        })
+    })
+})