✨ [RUM-3349] introduce a Consent Management API

packages/core/src/domain/session/sessionManager.spec.ts

@@ -1,10 +1,4 @@
-import {
-  createNewEvent,
-  mockClock,
-  mockExperimentalFeatures,
-  restorePageVisibility,
-  setPageVisibility,
-} from '../../../test'
+import { createNewEvent, mockClock, restorePageVisibility, setPageVisibility } from '../../../test'
 import type { Clock } from '../../../test'
 import { getCookie, setCookie } from '../../browser/cookie'
 import type { RelativeTime } from '../../tools/utils/timeUtils'
@@ -14,7 +8,6 @@ import { ONE_HOUR, ONE_SECOND } from '../../tools/utils/timeUtils'
 import type { Configuration } from '../configuration'
 import type { TrackingConsentState } from '../trackingConsent'
 import { TrackingConsent, createTrackingConsentState } from '../trackingConsent'
-import { ExperimentalFeature } from '../../tools/experimentalFeatures'
 import type { SessionManager } from './sessionManager'
 import { startSessionManager, stopSessionManager, VISIBILITY_CHECK_DELAY } from './sessionManager'
 import { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants'
@@ -525,10 +518,6 @@ describe('startSessionManager', () => {
   })
 
   describe('tracking consent', () => {
-    beforeEach(() => {
-      mockExperimentalFeatures([ExperimentalFeature.TRACKING_CONSENT])
-    })
-
     it('expires the session when tracking consent is withdrawn', () => {
       const trackingConsentState = createTrackingConsentState(TrackingConsent.GRANTED)
       const sessionManager = startSessionManagerWithDefaults({ trackingConsentState })

packages/core/src/domain/trackingConsent.spec.ts

@@ -1,71 +1,44 @@
-import { mockExperimentalFeatures } from '../../test'
-import { ExperimentalFeature } from '../tools/experimentalFeatures'
 import { TrackingConsent, createTrackingConsentState } from './trackingConsent'
 
 describe('createTrackingConsentState', () => {
-  describe('with tracking_consent enabled', () => {
-    beforeEach(() => {
-      mockExperimentalFeatures([ExperimentalFeature.TRACKING_CONSENT])
-    })
-
-    it('creates a tracking consent state', () => {
-      const trackingConsentState = createTrackingConsentState()
-      expect(trackingConsentState).toBeDefined()
-    })
-
-    it('defaults to not granted', () => {
-      const trackingConsentState = createTrackingConsentState()
-      expect(trackingConsentState.isGranted()).toBeFalse()
-    })
-
-    it('can be created with a default consent state', () => {
-      const trackingConsentState = createTrackingConsentState(TrackingConsent.GRANTED)
-      expect(trackingConsentState.isGranted()).toBeTrue()
-    })
-
-    it('can be updated to granted', () => {
-      const trackingConsentState = createTrackingConsentState()
-      trackingConsentState.update(TrackingConsent.GRANTED)
-      expect(trackingConsentState.isGranted()).toBeTrue()
-    })
-
-    it('notifies when the consent is updated', () => {
-      const spy = jasmine.createSpy()
-      const trackingConsentState = createTrackingConsentState()
-      trackingConsentState.observable.subscribe(spy)
-      trackingConsentState.update(TrackingConsent.GRANTED)
-      expect(spy).toHaveBeenCalledTimes(1)
-    })
+  it('creates a tracking consent state', () => {
+    const trackingConsentState = createTrackingConsentState()
+    expect(trackingConsentState).toBeDefined()
+  })
 
-    it('can init a consent state if not defined yet', () => {
-      const trackingConsentState = createTrackingConsentState()
-      trackingConsentState.tryToInit(TrackingConsent.GRANTED)
-      expect(trackingConsentState.isGranted()).toBeTrue()
-    })
+  it('defaults to not granted', () => {
+    const trackingConsentState = createTrackingConsentState()
+    expect(trackingConsentState.isGranted()).toBeFalse()
+  })
 
-    it('does not init a consent state if already defined', () => {
-      const trackingConsentState = createTrackingConsentState(TrackingConsent.GRANTED)
-      trackingConsentState.tryToInit(TrackingConsent.NOT_GRANTED)
-      expect(trackingConsentState.isGranted()).toBeTrue()
-    })
+  it('can be created with a default consent state', () => {
+    const trackingConsentState = createTrackingConsentState(TrackingConsent.GRANTED)
+    expect(trackingConsentState.isGranted()).toBeTrue()
   })
 
-  describe('with tracking_consent disabled', () => {
-    it('creates a tracking consent state', () => {
-      const trackingConsentState = createTrackingConsentState()
-      expect(trackingConsentState).toBeDefined()
-    })
+  it('can be updated to granted', () => {
+    const trackingConsentState = createTrackingConsentState()
+    trackingConsentState.update(TrackingConsent.GRANTED)
+    expect(trackingConsentState.isGranted()).toBeTrue()
+  })
 
-    it('is always granted', () => {
-      let trackingConsentState = createTrackingConsentState()
-      expect(trackingConsentState.isGranted()).toBeTrue()
+  it('notifies when the consent is updated', () => {
+    const spy = jasmine.createSpy()
+    const trackingConsentState = createTrackingConsentState()
+    trackingConsentState.observable.subscribe(spy)
+    trackingConsentState.update(TrackingConsent.GRANTED)
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
 
-      trackingConsentState = createTrackingConsentState(TrackingConsent.NOT_GRANTED)
-      expect(trackingConsentState.isGranted()).toBeTrue()
+  it('can init a consent state if not defined yet', () => {
+    const trackingConsentState = createTrackingConsentState()
+    trackingConsentState.tryToInit(TrackingConsent.GRANTED)
+    expect(trackingConsentState.isGranted()).toBeTrue()
+  })
 
-      trackingConsentState = createTrackingConsentState()
-      trackingConsentState.update(TrackingConsent.NOT_GRANTED)
-      expect(trackingConsentState.isGranted()).toBeTrue()
-    })
+  it('does not init a consent state if already defined', () => {
+    const trackingConsentState = createTrackingConsentState(TrackingConsent.GRANTED)
+    trackingConsentState.tryToInit(TrackingConsent.NOT_GRANTED)
+    expect(trackingConsentState.isGranted()).toBeTrue()
   })
 })

packages/core/src/domain/trackingConsent.ts

@@ -1,4 +1,3 @@
-import { ExperimentalFeature, isExperimentalFeatureEnabled } from '../tools/experimentalFeatures'
 import { Observable } from '../tools/observable'
 
 export const TrackingConsent = {
@@ -28,10 +27,7 @@ export function createTrackingConsentState(currentConsent?: TrackingConsent): Tr
       observable.notify()
     },
     isGranted() {
-      return (
-        !isExperimentalFeatureEnabled(ExperimentalFeature.TRACKING_CONSENT) ||
-        currentConsent === TrackingConsent.GRANTED
-      )
+      return currentConsent === TrackingConsent.GRANTED
     },
     observable,
   }

packages/core/src/tools/experimentalFeatures.ts

@@ -18,7 +18,6 @@ export enum ExperimentalFeature {
   ZERO_LCP_TELEMETRY = 'zero_lcp_telemetry',
   DISABLE_REPLAY_INLINE_CSS = 'disable_replay_inline_css',
   WRITABLE_RESOURCE_GRAPHQL = 'writable_resource_graphql',
-  TRACKING_CONSENT = 'tracking_consent',
   CUSTOM_VITALS = 'custom_vitals',
 }
 

packages/logs/src/boot/preStartLogs.spec.ts

@@ -1,12 +1,6 @@
-import { mockClock, type Clock, initEventBridgeStub, mockExperimentalFeatures } from '@datadog/browser-core/test'
+import { mockClock, type Clock, initEventBridgeStub } from '@datadog/browser-core/test'
 import type { TimeStamp, TrackingConsentState } from '@datadog/browser-core'
-import {
-  ExperimentalFeature,
-  ONE_SECOND,
-  TrackingConsent,
-  createTrackingConsentState,
-  display,
-} from '@datadog/browser-core'
+import { ONE_SECOND, TrackingConsent, createTrackingConsentState, display } from '@datadog/browser-core'
 import type { CommonContext } from '../rawLogsEvent.types'
 import type { HybridInitConfiguration, LogsConfiguration, LogsInitConfiguration } from '../domain/configuration'
 import { StatusType, type Logger } from '../domain/logger'
@@ -213,52 +207,30 @@ describe('preStartLogs', () => {
       strategy = createPreStartStrategy(getCommonContextSpy, trackingConsentState, doStartLogsSpy)
     })
 
-    describe('with tracking_consent enabled', () => {
-      beforeEach(() => {
-        mockExperimentalFeatures([ExperimentalFeature.TRACKING_CONSENT])
-      })
-
-      it('does not start logs if tracking consent is not granted at init', () => {
-        strategy.init({
-          ...DEFAULT_INIT_CONFIGURATION,
-          trackingConsent: TrackingConsent.NOT_GRANTED,
-        })
-        expect(doStartLogsSpy).not.toHaveBeenCalled()
-      })
-
-      it('starts logs if tracking consent is granted before init', () => {
-        trackingConsentState.update(TrackingConsent.GRANTED)
-        strategy.init({
-          ...DEFAULT_INIT_CONFIGURATION,
-          trackingConsent: TrackingConsent.NOT_GRANTED,
-        })
-        expect(doStartLogsSpy).toHaveBeenCalledTimes(1)
-      })
-
-      it('does not start logs if tracking consent is not withdrawn before init', () => {
-        trackingConsentState.update(TrackingConsent.NOT_GRANTED)
-        strategy.init({
-          ...DEFAULT_INIT_CONFIGURATION,
-          trackingConsent: TrackingConsent.GRANTED,
-        })
-        expect(doStartLogsSpy).not.toHaveBeenCalled()
+    it('does not start logs if tracking consent is not granted at init', () => {
+      strategy.init({
+        ...DEFAULT_INIT_CONFIGURATION,
+        trackingConsent: TrackingConsent.NOT_GRANTED,
       })
+      expect(doStartLogsSpy).not.toHaveBeenCalled()
     })
 
-    describe('with tracking_consent disabled', () => {
-      it('ignores the trackingConsent init param', () => {
-        strategy.init({
-          ...DEFAULT_INIT_CONFIGURATION,
-          trackingConsent: TrackingConsent.NOT_GRANTED,
-        })
-        expect(doStartLogsSpy).toHaveBeenCalled()
+    it('starts logs if tracking consent is granted before init', () => {
+      trackingConsentState.update(TrackingConsent.GRANTED)
+      strategy.init({
+        ...DEFAULT_INIT_CONFIGURATION,
+        trackingConsent: TrackingConsent.NOT_GRANTED,
       })
+      expect(doStartLogsSpy).toHaveBeenCalledTimes(1)
+    })
 
-      it('ignores setTrackingConsent', () => {
-        trackingConsentState.update(TrackingConsent.NOT_GRANTED)
-        strategy.init(DEFAULT_INIT_CONFIGURATION)
-        expect(doStartLogsSpy).toHaveBeenCalledTimes(1)
+    it('does not start logs if tracking consent is not withdrawn before init', () => {
+      trackingConsentState.update(TrackingConsent.NOT_GRANTED)
+      strategy.init({
+        ...DEFAULT_INIT_CONFIGURATION,
+        trackingConsent: TrackingConsent.GRANTED,
       })
+      expect(doStartLogsSpy).not.toHaveBeenCalled()
     })
 
     it('do not call startLogs when tracking consent state is updated after init', () => {

packages/rum-core/src/boot/preStartRum.spec.ts

@@ -6,7 +6,6 @@ import {
   relativeToClocks,
   clocksNow,
   TrackingConsent,
-  ExperimentalFeature,
   createTrackingConsentState,
   DefaultPrivacyLevel,
 } from '@datadog/browser-core'
@@ -15,7 +14,6 @@ import {
   cleanupSyntheticsWorkerValues,
   initEventBridgeStub,
   mockClock,
-  mockExperimentalFeatures,
   mockSyntheticsWorkerValues,
 } from '@datadog/browser-core/test'
 import type { HybridInitConfiguration, RumConfiguration, RumInitConfiguration } from '../domain/configuration'
@@ -333,7 +331,6 @@ describe('preStartRum', () => {
         })
 
         it('calling startView then init does not start rum if tracking consent is not granted', () => {
-          mockExperimentalFeatures([ExperimentalFeature.TRACKING_CONSENT])
           const strategy = createPreStartStrategy({}, getCommonContextSpy, createTrackingConsentState(), doStartRumSpy)
           strategy.startView({ name: 'foo' })
           strategy.init({
@@ -563,61 +560,39 @@ describe('preStartRum', () => {
       strategy = createPreStartStrategy({}, getCommonContextSpy, trackingConsentState, doStartRumSpy)
     })
 
-    describe('with tracking_consent enabled', () => {
-      beforeEach(() => {
-        mockExperimentalFeatures([ExperimentalFeature.TRACKING_CONSENT])
-      })
-
-      it('does not start rum if tracking consent is not granted at init', () => {
-        strategy.init({
-          ...DEFAULT_INIT_CONFIGURATION,
-          trackingConsent: TrackingConsent.NOT_GRANTED,
-        })
-        expect(doStartRumSpy).not.toHaveBeenCalled()
-      })
-
-      it('starts rum if tracking consent is granted before init', () => {
-        trackingConsentState.update(TrackingConsent.GRANTED)
-        strategy.init({
-          ...DEFAULT_INIT_CONFIGURATION,
-          trackingConsent: TrackingConsent.NOT_GRANTED,
-        })
-        expect(doStartRumSpy).toHaveBeenCalledTimes(1)
-      })
-
-      it('does not start rum if tracking consent is withdrawn before init', () => {
-        trackingConsentState.update(TrackingConsent.NOT_GRANTED)
-        strategy.init({
-          ...DEFAULT_INIT_CONFIGURATION,
-          trackingConsent: TrackingConsent.GRANTED,
-        })
-        expect(doStartRumSpy).not.toHaveBeenCalled()
+    it('does not start rum if tracking consent is not granted at init', () => {
+      strategy.init({
+        ...DEFAULT_INIT_CONFIGURATION,
+        trackingConsent: TrackingConsent.NOT_GRANTED,
       })
+      expect(doStartRumSpy).not.toHaveBeenCalled()
+    })
 
-      it('does not start rum if no view is started', () => {
-        trackingConsentState.update(TrackingConsent.GRANTED)
-        strategy.init({
-          ...MANUAL_CONFIGURATION,
-          trackingConsent: TrackingConsent.NOT_GRANTED,
-        })
-        expect(doStartRumSpy).not.toHaveBeenCalled()
+    it('starts rum if tracking consent is granted before init', () => {
+      trackingConsentState.update(TrackingConsent.GRANTED)
+      strategy.init({
+        ...DEFAULT_INIT_CONFIGURATION,
+        trackingConsent: TrackingConsent.NOT_GRANTED,
       })
+      expect(doStartRumSpy).toHaveBeenCalledTimes(1)
     })
 
-    describe('with tracking_consent disabled', () => {
-      it('ignores the trackingConsent init param', () => {
-        strategy.init({
-          ...DEFAULT_INIT_CONFIGURATION,
-          trackingConsent: TrackingConsent.NOT_GRANTED,
-        })
-        expect(doStartRumSpy).toHaveBeenCalled()
+    it('does not start rum if tracking consent is withdrawn before init', () => {
+      trackingConsentState.update(TrackingConsent.NOT_GRANTED)
+      strategy.init({
+        ...DEFAULT_INIT_CONFIGURATION,
+        trackingConsent: TrackingConsent.GRANTED,
       })
+      expect(doStartRumSpy).not.toHaveBeenCalled()
+    })
 
-      it('ignores setTrackingConsent', () => {
-        trackingConsentState.update(TrackingConsent.NOT_GRANTED)
-        strategy.init(DEFAULT_INIT_CONFIGURATION)
-        expect(doStartRumSpy).toHaveBeenCalledTimes(1)
+    it('does not start rum if no view is started', () => {
+      trackingConsentState.update(TrackingConsent.GRANTED)
+      strategy.init({
+        ...MANUAL_CONFIGURATION,
+        trackingConsent: TrackingConsent.NOT_GRANTED,
       })
+      expect(doStartRumSpy).not.toHaveBeenCalled()
     })
 
     it('do not call startRum when tracking consent state is updated after init', () => {