✨ [RUMF-998] introduce the initialPrivacyLevel configuration option

packages/core/src/domain/configuration.ts

@@ -1,9 +1,16 @@
 import { BuildEnv } from '../boot/init'
 import { CookieOptions, getCurrentSite } from '../browser/cookie'
 import { catchUserErrors } from '../tools/catchUserErrors'
-import { includes, ONE_KILO_BYTE, ONE_SECOND } from '../tools/utils'
+import { includes, objectHasValue, ONE_KILO_BYTE, ONE_SECOND } from '../tools/utils'
 import { computeTransportConfiguration } from './transportConfiguration'
 
+export const InitialPrivacyLevel = {
+  ALLOW: 'allow',
+  MASK: 'mask',
+  MASK_FORMS_ONLY: 'mask-forms-only',
+} as const
+export type InitialPrivacyLevel = typeof InitialPrivacyLevel[keyof typeof InitialPrivacyLevel]
+
 export const DEFAULT_CONFIGURATION = {
   allowedTracingOrigins: [] as Array<string | RegExp>,
   maxErrorsByMinute: 3000,
@@ -13,6 +20,7 @@ export const DEFAULT_CONFIGURATION = {
   silentMultipleInit: false,
   trackInteractions: false,
   trackViewsManually: false,
+  initialPrivacyLevel: InitialPrivacyLevel.ALLOW as InitialPrivacyLevel,
 
   /**
    * arbitrary value, byte precision not needed
@@ -53,6 +61,7 @@ export interface InitConfiguration {
   trackViewsManually?: boolean
   proxyHost?: string
   beforeSend?: BeforeSendCallback
+  initialPrivacyLevel?: InitialPrivacyLevel
 
   service?: string
   env?: string
@@ -143,6 +152,13 @@ export function buildConfiguration(initConfiguration: InitConfiguration, buildEn
     configuration.actionNameAttribute = initConfiguration.actionNameAttribute
   }
 
+  if (
+    configuration.isEnabled('initial-privacy-level-option') &&
+    objectHasValue(InitialPrivacyLevel, initConfiguration.initialPrivacyLevel)
+  ) {
+    configuration.initialPrivacyLevel = initConfiguration.initialPrivacyLevel
+  }
+
   return configuration
 }
 

packages/core/src/index.ts

@@ -4,6 +4,7 @@ export {
   InitConfiguration,
   buildCookieOptions,
   BeforeSendCallback,
+  InitialPrivacyLevel,
 } from './domain/configuration'
 export { trackConsoleError } from './domain/error/trackConsoleError'
 export { trackRuntimeError } from './domain/error/trackRuntimeError'

packages/core/src/tools/utils.ts

@@ -220,11 +220,11 @@ export function isNumber(value: unknown): value is number {
 }
 
 export function objectValues(object: { [key: string]: unknown }) {
-  const values: unknown[] = []
-  Object.keys(object).forEach((key) => {
-    values.push(object[key])
-  })
-  return values
+  return Object.keys(object).map((key) => object[key])
+}
+
+export function objectHasValue<T extends { [key: string]: unknown }>(object: T, value: unknown): value is T[keyof T] {
+  return Object.keys(object).some((key) => object[key] === value)
 }
 
 export function objectEntries(object: { [key: string]: unknown }): Array<[string, unknown]> {

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

@@ -1,7 +1,7 @@
-import { ONE_SECOND, RelativeTime, getTimeStamp, display, TimeStamp } from '@datadog/browser-core'
+import { ONE_SECOND, RelativeTime, getTimeStamp, display, TimeStamp, InitialPrivacyLevel } from '@datadog/browser-core'
 import { noopRecorderApi, setup, TestSetupBuilder } from '../../test/specHelper'
 import { ActionType } from '../rawRumEvent.types'
-import { makeRumPublicApi, RumPublicApi, RumInitConfiguration, StartRum } from './rumPublicApi'
+import { makeRumPublicApi, RumPublicApi, RumInitConfiguration, StartRum, RecorderApi } from './rumPublicApi'
 
 const noopStartRum = (): ReturnType<StartRum> => ({
   addAction: () => undefined,
@@ -652,4 +652,46 @@ describe('rum public api', () => {
       })
     })
   })
+
+  describe('recording', () => {
+    let recorderApiOnRumStartSpy: jasmine.Spy<RecorderApi['onRumStart']>
+    let setupBuilder: TestSetupBuilder
+    let rumPublicApi: RumPublicApi
+
+    beforeEach(() => {
+      recorderApiOnRumStartSpy = jasmine.createSpy('recorderApiOnRumStart')
+      rumPublicApi = makeRumPublicApi(noopStartRum, { ...noopRecorderApi, onRumStart: recorderApiOnRumStartSpy })
+      setupBuilder = setup()
+    })
+
+    afterEach(() => {
+      setupBuilder.cleanup()
+    })
+
+    it('recording is started with the default initialPrivacyLevel', () => {
+      rumPublicApi.init(DEFAULT_INIT_CONFIGURATION)
+      expect(recorderApiOnRumStartSpy.calls.mostRecent().args[2].initialPrivacyLevel).toBe(InitialPrivacyLevel.ALLOW)
+    })
+
+    describe('initial-privacy-level-option feature enabled', () => {
+      it('recording is started with the configured initialPrivacyLevel', () => {
+        rumPublicApi.init({
+          ...DEFAULT_INIT_CONFIGURATION,
+          initialPrivacyLevel: InitialPrivacyLevel.MASK,
+          enableExperimentalFeatures: ['initial-privacy-level-option'],
+        })
+        expect(recorderApiOnRumStartSpy.calls.mostRecent().args[2].initialPrivacyLevel).toBe(InitialPrivacyLevel.MASK)
+      })
+    })
+
+    describe('initial-privacy-level-option feature disabled', () => {
+      it('recording ignores the configured initialPrivacyLevel', () => {
+        rumPublicApi.init({
+          ...DEFAULT_INIT_CONFIGURATION,
+          initialPrivacyLevel: InitialPrivacyLevel.MASK,
+        })
+        expect(recorderApiOnRumStartSpy.calls.mostRecent().args[2].initialPrivacyLevel).toBe(InitialPrivacyLevel.ALLOW)
+      })
+    })
+  })
 })

packages/rum-core/src/boot/rumPublicApi.ts

@@ -18,6 +18,7 @@ import {
   InternalMonitoring,
   callMonitored,
   createHandlingStack,
+  InitialPrivacyLevel,
 } from '@datadog/browser-core'
 import { LifeCycle } from '../domain/lifeCycle'
 import { ParentContexts } from '../domain/parentContexts'
@@ -31,6 +32,7 @@ import { startRum } from './startRum'
 export interface RumInitConfiguration extends InitConfiguration {
   applicationId: string
   beforeSend?: (event: RumEvent, context: RumEventDomainContext) => void | boolean
+  initialPrivacyLevel?: InitialPrivacyLevel
 }
 
 export type RumPublicApi = ReturnType<typeof makeRumPublicApi>

packages/rum-slim/src/index.ts

@@ -21,3 +21,4 @@ export {
   RumOtherResourceEventDomainContext,
   RumLongTaskEventDomainContext,
 } from '@datadog/browser-rum-core'
+export { InitialPrivacyLevel } from '@datadog/browser-core'

packages/rum/src/boot/startRecording.ts

@@ -27,6 +27,7 @@ export function startRecording(
 
   const { stop: stopRecording, takeFullSnapshot, flushMutations } = record({
     emit: addRawRecord,
+    initialPrivacyLevel: configuration.initialPrivacyLevel,
   })
 
   const { unsubscribe: unsubscribeViewEnded } = lifeCycle.subscribe(LifeCycleEventType.VIEW_ENDED, () => {

packages/rum/src/constants.ts

@@ -1,22 +1,15 @@
+import { InitialPrivacyLevel } from '@datadog/browser-core'
+
 export const NodePrivacyLevel = {
-  IGNORE: 'IGNORE',
-  ALLOW: 'ALLOW',
-  MASK: 'MASK',
-  HIDDEN: 'HIDDEN',
+  ...InitialPrivacyLevel,
+  IGNORE: 'ignore',
+  HIDDEN: 'hidden',
 } as const
 export type NodePrivacyLevel = typeof NodePrivacyLevel[keyof typeof NodePrivacyLevel]
 
-export const NodePrivacyLevelInternal = {
-  // INTERNAL USE: not to be used by the general codebase
-  NOT_SET: 'NOT_SET',
-  MASK_FORMS_ONLY: 'MASK_FORMS_ONLY',
-  ...NodePrivacyLevel,
-} as const
-export type NodePrivacyLevelInternal = typeof NodePrivacyLevelInternal[keyof typeof NodePrivacyLevelInternal]
-
 export const PRIVACY_ATTR_NAME = 'data-dd-privacy'
 
-// Deprecate via temporariy Alias
+// Deprecate via temporary Alias
 export const PRIVACY_CLASS_INPUT_IGNORED = 'dd-privacy-input-ignored' // DEPRECATED, aliased to mask-forms-only
 export const PRIVACY_CLASS_INPUT_MASKED = 'dd-privacy-input-masked' // DEPRECATED, aliased to mask-forms-only
 export const PRIVACY_ATTR_VALUE_INPUT_IGNORED = 'input-ignored' // DEPRECATED, aliased to mask-forms-only