DataDog · cy-moi · Jun 23, 2025 · Jun 23, 2025 · Jun 25, 2025 · Jun 27, 2025
@@ -25,6 +25,7 @@ export const DefaultPrivacyLevel = {
   ALLOW: 'allow',
   MASK: 'mask',
   MASK_USER_INPUT: 'mask-user-input',
+  MASK_UNLESS_ALLOWLISTED: 'mask-unless-allowlisted',
 } as const
 export type DefaultPrivacyLevel = (typeof DefaultPrivacyLevel)[keyof typeof DefaultPrivacyLevel]
 

@@ -11,6 +11,7 @@ import { createHooks } from '../hooks'
 import type { RumMutationRecord } from '../../browser/domMutationObservable'
 import type { ActionContexts } from './actionCollection'
 import { startActionCollection } from './actionCollection'
+import { ActionNameSource } from './actionNameConstants'
 
 describe('actionCollection', () => {
   const lifeCycle = new LifeCycle()
@@ -50,7 +51,7 @@ describe('actionCollection', () => {
       duration: 100 as Duration,
       id: 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
       name: 'foo',
-      nameSource: 'text_content',
+      nameSource: ActionNameSource.TEXT_CONTENT,
       startClocks: { relative: 1234 as RelativeTime, timeStamp: 123456789 as TimeStamp },
       type: ActionType.CLICK,
       event,
@@ -145,7 +146,7 @@ describe('actionCollection', () => {
       frustrationTypes: [],
       id: 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
       name: 'foo',
-      nameSource: 'text_content',
+      nameSource: ActionNameSource.TEXT_CONTENT,
       startClocks: { relative: 0 as RelativeTime, timeStamp: 0 as TimeStamp },
       type: ActionType.CLICK,
     })

@@ -31,8 +31,11 @@ export function startActionCollection(
   windowOpenObservable: Observable<void>,
   configuration: RumConfiguration
 ) {
-  lifeCycle.subscribe(LifeCycleEventType.AUTO_ACTION_COMPLETED, (action) =>
-    lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processAction(action))
+  const { unsubscribe: unsubscribeAutoActionCompleted } = lifeCycle.subscribe(
+    LifeCycleEventType.AUTO_ACTION_COMPLETED,
+    (action) => {
+      lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processAction(action))
+    }
   )
 
   hooks.register(HookNames.Assemble, ({ startTime, eventType }): DefaultRumEventAttributes | SKIPPED => {
@@ -79,7 +82,10 @@ export function startActionCollection(
       lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processAction(action))
     },
     actionContexts,
-    stop,
+    stop: () => {
+      unsubscribeAutoActionCompleted()
+      stop()
+    },
   }
 }
 

@@ -0,0 +1,18 @@
+/**
+ * Get the action name from the attribute 'data-dd-action-name' on the element or any of its parent.
+ * It can also be retrieved from a user defined attribute.
+ */
+export const DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE = 'data-dd-action-name'
+export const ACTION_NAME_PLACEHOLDER = 'Masked Element'
+export const enum ActionNameSource {
+  CUSTOM_ATTRIBUTE = 'custom_attribute',
+  MASK_PLACEHOLDER = 'mask_placeholder',
+  TEXT_CONTENT = 'text_content',
+  STANDARD_ATTRIBUTE = 'standard_attribute',
+  BLANK = 'blank',
+  MASK_DISALLOWED = 'mask_disallowed',
+}
+export interface ActionName {
+  name: string
+  nameSource: ActionNameSource
+}
@@ -1,6 +1,7 @@
 import { appendElement, mockRumConfiguration } from '../../../test'
-import { NodePrivacyLevel } from '../privacy'
-import { ActionNameSource, getActionNameFromElement } from './getActionNameFromElement'
+import { NodePrivacyLevel } from '../privacyConstants'
+import { getActionNameFromElement } from './getActionNameFromElement'
+import { ActionNameSource } from './actionNameConstants'
 
 const defaultConfiguration = mockRumConfiguration()
 
@@ -663,4 +664,172 @@ describe('getActionNameFromElement', () => {
       })
     })
   })
+
+  describe('Mask with allowlist for action names', () => {
+    describe('when privacyEnabledActionName is false', () => {
+      beforeEach(() => {
+        window.$DD_ALLOW = new Set(['allowed text', 'button text'])
+      })
+
+      afterEach(() => {
+        window.$DD_ALLOW = undefined
+      })
+
+      it('applies maskActionName when privacy level is MASK_UNLESS_ALLOWLISTED', () => {
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<button>secret text</button>'),
+          {
+            ...defaultConfiguration,
+            defaultPrivacyLevel: NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED,
+            enablePrivacyForActionName: false,
+          },
+          NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED
+        )
+        expect(name).toBe('Masked Element')
+        expect(nameSource).toBe('mask_disallowed')
+      })
+
+      it('preserves allowlisted text when privacy level is MASK_UNLESS_ALLOWLISTED', () => {
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<button>allowed text</button>'),
+          {
+            ...defaultConfiguration,
+          },
+          NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED
+        )
+        expect(name).toBe('allowed text')
+        expect(nameSource).toBe('text_content')
+      })
+
+      // TODO: remove this comment after we make enablePrivacyForActionName true by default
+      // This case should not happen in the field for now, because we do not set node privacy level to MASK
+      // when enablePrivacyForActionName is false in the configuration yet
+      it('apply mask placeholder when privacy level is MASK if DD_ALLOW is not empty', () => {
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<button>any text</button>'),
+          {
+            ...defaultConfiguration,
+          },
+          NodePrivacyLevel.MASK
+        )
+        expect(name).toBe('Masked Element')
+        expect(nameSource).toBe('mask_placeholder')
+      })
+
+      it('does not apply masking when privacy level is ALLOW', () => {
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<button>any text</button>'),
+          {
+            ...defaultConfiguration,
+          },
+          NodePrivacyLevel.ALLOW
+        )
+        expect(name).toBe('any text')
+        expect(nameSource).toBe('text_content')
+      })
+
+      it('handles empty allowlist with MASK_UNLESS_ALLOWLISTED privacy level', () => {
+        window.$DD_ALLOW = new Set()
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<button>any text</button>'),
+          {
+            ...defaultConfiguration,
+            enablePrivacyForActionName: false,
+          },
+          NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED
+        )
+        expect(name).toBe('Masked Element')
+        expect(nameSource).toBe('mask_disallowed')
+      })
+
+      it('handles undefined allowlist with MASK_UNLESS_ALLOWLISTED privacy level', () => {
+        window.$DD_ALLOW = undefined
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<button>any text</button>'),
+          {
+            ...defaultConfiguration,
+            enablePrivacyForActionName: false,
+          },
+          NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED
+        )
+        expect(name).toBe('Masked Element')
+        expect(nameSource).toBe('mask_disallowed')
+      })
+
+      it('applies masking to input button values when not allowlisted', () => {
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<input type="button" value="secret button" />'),
+          {
+            ...defaultConfiguration,
+            enablePrivacyForActionName: false,
+          },
+          NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED
+        )
+        expect(name).toBe('Masked Element')
+        expect(nameSource).toBe('mask_disallowed')
+      })
+
+      it('preserves input button values when allowlisted', () => {
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<input type="button" value="button text" />'),
+          {
+            ...defaultConfiguration,
+            enablePrivacyForActionName: false,
+          },
+          NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED
+        )
+        expect(name).toBe('button text')
+        expect(nameSource).toBe('text_content')
+      })
+
+      it('applies masking to aria-label when not allowlisted', () => {
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<span aria-label="secret label" />'),
+          {
+            ...defaultConfiguration,
+            enablePrivacyForActionName: false,
+          },
+          NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED
+        )
+        expect(name).toBe('Masked Element')
+        expect(nameSource).toBe('mask_disallowed')
+      })
+
+      it('preserves aria-label when allowlisted', () => {
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<span aria-label="allowed text" />'),
+          {
+            ...defaultConfiguration,
+            enablePrivacyForActionName: false,
+          },
+          NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED
+        )
+        expect(name).toBe('allowed text')
+        expect(nameSource).toBe('standard_attribute')
+      })
+    })
+
+    describe('when privacyEnabledActionName is true', () => {
+      beforeEach(() => {
+        window.$DD_ALLOW = new Set(['allowed text'])
+      })
+
+      afterEach(() => {
+        window.$DD_ALLOW = undefined
+      })
+
+      it('should use allowlist masking when nodePrivacyLevel is MASK_UNLESS_ALLOWLISTED', () => {
+        const { name, nameSource } = getActionNameFromElement(
+          appendElement('<button>secret text</button>'),
+          {
+            ...defaultConfiguration,
+            enablePrivacyForActionName: true,
+          },
+          NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED
+        )
+        expect(name).toBe('Masked Element')
+        expect(nameSource).toBe('mask_disallowed')
+      })
+    })
+  })
 })
@@ -1,28 +1,17 @@
-import { safeTruncate } from '@datadog/browser-core'
-import { NodePrivacyLevel, getPrivacySelector } from '../privacy'
+import { DefaultPrivacyLevel, safeTruncate } from '@datadog/browser-core'
+import { NodePrivacyLevel, getPrivacySelector } from '../privacyConstants'
 import type { RumConfiguration } from '../configuration'
-
-/**
- * Get the action name from the attribute 'data-dd-action-name' on the element or any of its parent.
- * It can also be retrieved from a user defined attribute.
- */
-export const DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE = 'data-dd-action-name'
-export const ACTION_NAME_PLACEHOLDER = 'Masked Element'
-export const enum ActionNameSource {
-  CUSTOM_ATTRIBUTE = 'custom_attribute',
-  MASK_PLACEHOLDER = 'mask_placeholder',
-  TEXT_CONTENT = 'text_content',
-  STANDARD_ATTRIBUTE = 'standard_attribute',
-  BLANK = 'blank',
-}
-interface ActionName {
-  name: string
-  nameSource: ActionNameSource
-}
+import { maskDisallowedActionName } from './privacy/maskWithAllowlist'
+import {
+  ActionNameSource,
+  DEFAULT_PROGRAMMATIC_ACTION_NAME_ATTRIBUTE,
+  ACTION_NAME_PLACEHOLDER,
+} from './actionNameConstants'
+import type { ActionName } from './actionNameConstants'
 
 export function getActionNameFromElement(
   element: Element,
-  { enablePrivacyForActionName, actionNameAttribute: userProgrammaticAttribute }: RumConfiguration,
+  { enablePrivacyForActionName, actionNameAttribute: userProgrammaticAttribute, defaultPrivacyLevel }: RumConfiguration,
   nodePrivacyLevel?: NodePrivacyLevel
 ): ActionName {
   // Proceed to get the action name in two steps:
@@ -47,12 +36,16 @@ export function getActionNameFromElement(
       element,
       userProgrammaticAttribute,
       priorityStrategies,
+      defaultPrivacyLevel,
+      nodePrivacyLevel,
       enablePrivacyForActionName
     ) ||
     getActionNameFromElementForStrategies(
       element,
       userProgrammaticAttribute,
       fallbackStrategies,
+      defaultPrivacyLevel,
+      nodePrivacyLevel,
       enablePrivacyForActionName
     ) || { name: '', nameSource: ActionNameSource.BLANK }
   )
@@ -141,6 +134,8 @@ function getActionNameFromElementForStrategies(
   targetElement: Element,
   userProgrammaticAttribute: string | undefined,
   strategies: NameStrategy[],
+  defaultPrivacyLevel: DefaultPrivacyLevel,
+  nodeSelfPrivacy?: NodePrivacyLevel,
   privacyEnabledActionName?: boolean
 ) {
   let element: Element | null = targetElement
@@ -155,7 +150,12 @@ function getActionNameFromElementForStrategies(
     for (const strategy of strategies) {
       const actionName = strategy(element, userProgrammaticAttribute, privacyEnabledActionName)
       if (actionName) {
-        const { name, nameSource } = actionName
+        const { name, nameSource } =
+          (defaultPrivacyLevel === DefaultPrivacyLevel.MASK_UNLESS_ALLOWLISTED &&
+            nodeSelfPrivacy !== NodePrivacyLevel.ALLOW) ||
+          nodeSelfPrivacy === NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED
+            ? maskDisallowedActionName(actionName)
+            : actionName
         const trimmedName = name && name.trim()
         if (trimmedName) {
           return { name: truncate(normalizeWhitespace(trimmedName)), nameSource }

@@ -0,0 +1,58 @@
+import { ActionType } from '../../../rawRumEvent.types'
+import { ActionNameSource } from '../actionNameConstants'
+import type { ClickActionBase } from '../trackClickActions'
+import { maskDisallowedActionName } from './maskWithAllowlist'
+
+const TEST_STRINGS = {
+  COMPLEX_MIXED: 'test-team-name:💥$$$',
+  PARAGRAPH_MIXED: '✅ This is an action name in allowlist',
+}
+
+describe('maskWithAllowlist', () => {
+  const clickActionBase: ClickActionBase = {
+    type: ActionType.CLICK,
+    name: '',
+    nameSource: ActionNameSource.MASK_DISALLOWED,
+    target: {
+      selector: 'button',
+      width: 100,
+      height: 100,
+    },
+    position: { x: 0, y: 0 },
+  }
+
+  beforeEach(() => {
+    window.$DD_ALLOW = new Set([TEST_STRINGS.PARAGRAPH_MIXED])
+  })
+
+  afterEach(() => {
+    window.$DD_ALLOW = undefined
+  })
+
+  it('should fail close if $DD_ALLOW is not defined', () => {
+    window.$DD_ALLOW = undefined as any
+    clickActionBase.name = 'mask-feature-on'
+    const testString = maskDisallowedActionName(clickActionBase)
+    expect(testString.name).toBe('Masked Element')
+    expect(testString.nameSource).toBe(ActionNameSource.MASK_DISALLOWED)
+  })
+
+  it('masks words not in allowlist (with dictionary from $DD_ALLOW)', () => {
+    clickActionBase.name = 'This is an action name in allowlist'
+    const testString1 = maskDisallowedActionName(clickActionBase)
+    expect(testString1.name).toBe('Masked Element')
+    expect(testString1.nameSource).toBe(ActionNameSource.MASK_DISALLOWED)
+
+    clickActionBase.name = 'any unallowed string'
+    const testString2 = maskDisallowedActionName(clickActionBase)
+    expect(testString2.name).toBe('Masked Element')
+    expect(testString2.nameSource).toBe(ActionNameSource.MASK_DISALLOWED)
+  })
+
+  it('handles empty string', () => {
+    clickActionBase.name = ''
+    const result = maskDisallowedActionName(clickActionBase)
+    expect(result.name).toBe('')
+    expect(result.nameSource).toBe(ActionNameSource.MASK_DISALLOWED)
+  })
+})