🎨 [PANA-4398] Convert SerializeOptions#parentNodePrivacyLevel into a normal function argument (#3893)

Author: sethfowler-datadog

packages/rum/src/domain/record/serialization/htmlAst.specHelper.ts

@@ -43,8 +43,7 @@ const DEFAULT_SHADOW_ROOT_CONTROLLER = {
 export const generateLeanSerializedDoc = (htmlContent: string, privacyTag: string) => {
   const newDoc = makeHtmlDoc(htmlContent, privacyTag)
   const serializedDoc = removeIdFieldsRecursivelyClone(
-    serializeNodeWithId(newDoc, {
-      parentNodePrivacyLevel: NodePrivacyLevel.ALLOW,
+    serializeNodeWithId(newDoc, NodePrivacyLevel.ALLOW, {
       serializationContext: {
         serializationStats: createSerializationStats(),
         shadowRootsController: DEFAULT_SHADOW_ROOT_CONTROLLER,

packages/rum/src/domain/record/serialization/serialization.types.ts

@@ -7,7 +7,7 @@ import type { SerializationStats } from './serializationStats'
 // Those values are the only one that can be used when inheriting privacy levels from parent to
 // children during serialization, since HIDDEN and IGNORE shouldn't serialize their children. This
 // ensures that no children are serialized when they shouldn't.
-type ParentNodePrivacyLevel =
+export type ParentNodePrivacyLevel =
   | typeof NodePrivacyLevel.ALLOW
   | typeof NodePrivacyLevel.MASK
   | typeof NodePrivacyLevel.MASK_USER_INPUT
@@ -40,7 +40,6 @@ export type SerializationContext =
 
 export interface SerializeOptions {
   serializedNodeIds?: Set<number>
-  parentNodePrivacyLevel: ParentNodePrivacyLevel
   serializationContext: SerializationContext
   configuration: RumConfiguration
   scope: SerializationScope

packages/rum/src/domain/record/serialization/serializeDocument.ts

@@ -13,9 +13,8 @@ export function serializeDocument(
   serializationContext: SerializationContext
 ): SerializedNodeWithId {
   const serializationStart = timeStampNow()
-  const serializedNode = serializeNodeWithId(document, {
+  const serializedNode = serializeNodeWithId(document, configuration.defaultPrivacyLevel, {
     serializationContext,
-    parentNodePrivacyLevel: configuration.defaultPrivacyLevel,
     configuration,
     scope,
   })

packages/rum/src/domain/record/serialization/serializeNode.spec.ts

@@ -58,7 +58,6 @@ describe('serializeNodeWithId', () => {
   let scope: SerializationScope
 
   const getDefaultOptions = (): SerializeOptions => ({
-    parentNodePrivacyLevel: NodePrivacyLevel.ALLOW,
     serializationContext: getDefaultSerializationContext(),
     configuration: DEFAULT_CONFIGURATION,
     scope,
@@ -89,7 +88,9 @@ describe('serializeNodeWithId', () => {
       node: Element,
       options: SerializeOptions | undefined = undefined
     ): (ElementNode & { id: number }) | null {
-      return serializeNodeWithId(node, options ?? getDefaultOptions()) as (ElementNode & { id: number }) | null
+      return serializeNodeWithId(node, NodePrivacyLevel.ALLOW, options ?? getDefaultOptions()) as
+        | (ElementNode & { id: number })
+        | null
     }
 
     it('serializes a div', () => {
@@ -670,7 +671,7 @@ describe('serializeNodeWithId', () => {
         )
 
         const options = getDefaultOptions()
-        expect(serializeNodeWithId(linkNode, options)).toEqual({
+        expect(serializeNodeWithId(linkNode, NodePrivacyLevel.ALLOW, options)).toEqual({
           type: NodeType.Element,
           tagName: 'link',
           id: jasmine.any(Number) as unknown as number,
@@ -700,7 +701,7 @@ describe('serializeNodeWithId', () => {
         })
 
         const options = getDefaultOptions()
-        expect(serializeNodeWithId(linkNode, options)).toEqual({
+        expect(serializeNodeWithId(linkNode, NodePrivacyLevel.ALLOW, options)).toEqual({
           type: NodeType.Element,
           tagName: 'link',
           id: jasmine.any(Number) as unknown as number,
@@ -737,7 +738,7 @@ describe('serializeNodeWithId', () => {
         })
 
         const options = getDefaultOptions()
-        expect(serializeNodeWithId(linkNode, options)).toEqual({
+        expect(serializeNodeWithId(linkNode, NodePrivacyLevel.ALLOW, options)).toEqual({
           type: NodeType.Element,
           tagName: 'link',
           id: jasmine.any(Number) as unknown as number,
@@ -762,7 +763,7 @@ describe('serializeNodeWithId', () => {
       parentEl.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_ALLOW)
       const textNode = document.createTextNode('foo')
       parentEl.appendChild(textNode)
-      expect(serializeNodeWithId(textNode, getDefaultOptions())).toEqual({
+      expect(serializeNodeWithId(textNode, NodePrivacyLevel.ALLOW, getDefaultOptions())).toEqual({
         type: NodeType.Text,
         id: jasmine.any(Number) as unknown as number,
         textContent: 'foo',
@@ -773,7 +774,7 @@ describe('serializeNodeWithId', () => {
       const parentEl = document.createElement('bar')
       const textNode = document.createTextNode('')
       parentEl.appendChild(textNode)
-      expect(serializeNodeWithId(textNode, getDefaultOptions())).toEqual({
+      expect(serializeNodeWithId(textNode, NodePrivacyLevel.ALLOW, getDefaultOptions())).toEqual({
         type: NodeType.Text,
         id: jasmine.any(Number) as unknown as number,
         textContent: '',
@@ -784,15 +785,17 @@ describe('serializeNodeWithId', () => {
       const head = document.getElementsByTagName('head')[0]
       const textNode = document.createTextNode('   ')
       head.appendChild(textNode)
-      expect(serializeNodeWithId(textNode, getDefaultOptions())).toEqual(null)
+      expect(serializeNodeWithId(textNode, NodePrivacyLevel.ALLOW, getDefaultOptions())).toEqual(null)
       head.removeChild(textNode)
     })
   })
 
   describe('CDATA nodes serialization', () => {
     it('serializes a CDATA node', () => {
       const xmlDocument = new DOMParser().parseFromString('<root></root>', 'text/xml')
-      expect(serializeNodeWithId(xmlDocument.createCDATASection('foo'), getDefaultOptions())).toEqual({
+      expect(
+        serializeNodeWithId(xmlDocument.createCDATASection('foo'), NodePrivacyLevel.ALLOW, getDefaultOptions())
+      ).toEqual({
         type: NodeType.CDATA,
         id: jasmine.any(Number) as unknown as number,
         textContent: '',
@@ -802,47 +805,55 @@ describe('serializeNodeWithId', () => {
 
   it('adds serialized node ids to the provided Set', () => {
     const serializedNodeIds = new Set<number>()
-    const node = serializeNodeWithId(document.createElement('div'), { ...getDefaultOptions(), serializedNodeIds })!
+    const node = serializeNodeWithId(document.createElement('div'), NodePrivacyLevel.ALLOW, {
+      ...getDefaultOptions(),
+      serializedNodeIds,
+    })!
     expect(serializedNodeIds).toEqual(new Set([node.id]))
   })
 
   describe('ignores some nodes', () => {
     it('does not save ignored nodes in the serializedNodeIds set', () => {
       const serializedNodeIds = new Set<number>()
-      serializeNodeWithId(document.createElement('script'), { ...getDefaultOptions(), serializedNodeIds })
+      serializeNodeWithId(document.createElement('script'), NodePrivacyLevel.ALLOW, {
+        ...getDefaultOptions(),
+        serializedNodeIds,
+      })
       expect(serializedNodeIds.size).toBe(0)
     })
 
     it('does not serialize ignored nodes', () => {
       const scriptElement = document.createElement('script')
-      serializeNodeWithId(scriptElement, getDefaultOptions())
+      serializeNodeWithId(scriptElement, NodePrivacyLevel.ALLOW, getDefaultOptions())
       expect(scope.nodeIds.get(scriptElement)).toBe(undefined)
     })
 
     it('ignores script tags', () => {
-      expect(serializeNodeWithId(document.createElement('script'), getDefaultOptions())).toEqual(null)
+      const scriptElement = document.createElement('script')
+      expect(serializeNodeWithId(scriptElement, NodePrivacyLevel.ALLOW, getDefaultOptions())).toEqual(null)
     })
 
     it('ignores comments', () => {
-      expect(serializeNodeWithId(document.createComment('foo'), getDefaultOptions())).toEqual(null)
+      const commentNode = document.createComment('foo')
+      expect(serializeNodeWithId(commentNode, NodePrivacyLevel.ALLOW, getDefaultOptions())).toEqual(null)
     })
 
     it('ignores link favicons', () => {
       const linkElement = document.createElement('link')
       linkElement.setAttribute('rel', 'shortcut icon')
-      expect(serializeNodeWithId(linkElement, getDefaultOptions())).toEqual(null)
+      expect(serializeNodeWithId(linkElement, NodePrivacyLevel.ALLOW, getDefaultOptions())).toEqual(null)
     })
 
     it('ignores meta keywords', () => {
       const metaElement = document.createElement('meta')
       metaElement.setAttribute('name', 'keywords')
-      expect(serializeNodeWithId(metaElement, getDefaultOptions())).toEqual(null)
+      expect(serializeNodeWithId(metaElement, NodePrivacyLevel.ALLOW, getDefaultOptions())).toEqual(null)
     })
 
     it('ignores meta name attribute casing', () => {
       const metaElement = document.createElement('meta')
       metaElement.setAttribute('name', 'KeYwOrDs')
-      expect(serializeNodeWithId(metaElement, getDefaultOptions())).toEqual(null)
+      expect(serializeNodeWithId(metaElement, NodePrivacyLevel.ALLOW, getDefaultOptions())).toEqual(null)
     })
   })
 
@@ -994,7 +1005,6 @@ describe('serializeDocumentNode handles', function testAllowDomTree() {
   let scope: SerializationScope
 
   const getDefaultOptions = (): SerializeOptions => ({
-    parentNodePrivacyLevel: NodePrivacyLevel.ALLOW,
     serializationContext: getDefaultSerializationContext(),
     configuration: DEFAULT_CONFIGURATION,
     scope,
@@ -1036,13 +1046,9 @@ describe('serializeDocumentNode handles', function testAllowDomTree() {
   })
 
   it('a masked DOM Document itself is still serialized ', () => {
-    const serializeOptionsMask: SerializeOptions = {
-      ...getDefaultOptions(),
-      parentNodePrivacyLevel: NodePrivacyLevel.MASK,
-    }
-    expect(serializeDocumentNode(document, serializeOptionsMask)).toEqual({
+    expect(serializeDocumentNode(document, NodePrivacyLevel.MASK, getDefaultOptions())).toEqual({
       type: NodeType.Document,
-      childNodes: serializeChildNodes(document, serializeOptionsMask),
+      childNodes: serializeChildNodes(document, NodePrivacyLevel.MASK, getDefaultOptions()),
       adoptedStyleSheets: undefined,
     })
   })

packages/rum/src/domain/record/serialization/serializeNode.ts

@@ -21,12 +21,16 @@ import type {
 } from '../../../types'
 import { NodeType } from '../../../types'
 import { getValidTagName } from './serializationUtils'
-import type { SerializeOptions } from './serialization.types'
+import type { ParentNodePrivacyLevel, SerializeOptions } from './serialization.types'
 import { serializeStyleSheets } from './serializeStyleSheets'
 import { serializeAttributes } from './serializeAttributes'
 
-export function serializeNodeWithId(node: Node, options: SerializeOptions): SerializedNodeWithId | null {
-  const serializedNode = serializeNode(node, options)
+export function serializeNodeWithId(
+  node: Node,
+  parentNodePrivacyLevel: ParentNodePrivacyLevel,
+  options: SerializeOptions
+): SerializedNodeWithId | null {
+  const serializedNode = serializeNode(node, parentNodePrivacyLevel, options)
   if (!serializedNode) {
     return null
   }
@@ -40,44 +44,57 @@ export function serializeNodeWithId(node: Node, options: SerializeOptions): Seri
   return serializedNodeWithId
 }
 
-export function serializeChildNodes(node: Node, options: SerializeOptions): SerializedNodeWithId[] {
+export function serializeChildNodes(
+  node: Node,
+  parentNodePrivacyLevel: ParentNodePrivacyLevel,
+  options: SerializeOptions
+): SerializedNodeWithId[] {
   const result: SerializedNodeWithId[] = []
   forEachChildNodes(node, (childNode) => {
-    const serializedChildNode = serializeNodeWithId(childNode, options)
+    const serializedChildNode = serializeNodeWithId(childNode, parentNodePrivacyLevel, options)
     if (serializedChildNode) {
       result.push(serializedChildNode)
     }
   })
   return result
 }
 
-function serializeNode(node: Node, options: SerializeOptions): SerializedNode | undefined {
+function serializeNode(
+  node: Node,
+  parentNodePrivacyLevel: ParentNodePrivacyLevel,
+  options: SerializeOptions
+): SerializedNode | undefined {
   switch (node.nodeType) {
     case node.DOCUMENT_NODE:
-      return serializeDocumentNode(node as Document, options)
+      return serializeDocumentNode(node as Document, parentNodePrivacyLevel, options)
     case node.DOCUMENT_FRAGMENT_NODE:
-      return serializeDocumentFragmentNode(node as DocumentFragment, options)
+      return serializeDocumentFragmentNode(node as DocumentFragment, parentNodePrivacyLevel, options)
     case node.DOCUMENT_TYPE_NODE:
       return serializeDocumentTypeNode(node as DocumentType)
     case node.ELEMENT_NODE:
-      return serializeElementNode(node as Element, options)
+      return serializeElementNode(node as Element, parentNodePrivacyLevel, options)
     case node.TEXT_NODE:
-      return serializeTextNode(node as Text, options)
+      return serializeTextNode(node as Text, parentNodePrivacyLevel)
     case node.CDATA_SECTION_NODE:
       return serializeCDataNode()
   }
 }
 
-export function serializeDocumentNode(document: Document, options: SerializeOptions): DocumentNode {
+export function serializeDocumentNode(
+  document: Document,
+  parentNodePrivacyLevel: ParentNodePrivacyLevel,
+  options: SerializeOptions
+): DocumentNode {
   return {
     type: NodeType.Document,
-    childNodes: serializeChildNodes(document, options),
+    childNodes: serializeChildNodes(document, parentNodePrivacyLevel, options),
     adoptedStyleSheets: serializeStyleSheets(document.adoptedStyleSheets),
   }
 }
 
 function serializeDocumentFragmentNode(
   element: DocumentFragment,
+  parentNodePrivacyLevel: ParentNodePrivacyLevel,
   options: SerializeOptions
 ): DocumentFragmentNode | undefined {
   const isShadowRoot = isNodeShadowRoot(element)
@@ -87,7 +104,7 @@ function serializeDocumentFragmentNode(
 
   return {
     type: NodeType.DocumentFragment,
-    childNodes: serializeChildNodes(element, options),
+    childNodes: serializeChildNodes(element, parentNodePrivacyLevel, options),
     isShadowRoot,
     adoptedStyleSheets: isShadowRoot ? serializeStyleSheets(element.adoptedStyleSheets) : undefined,
   }
@@ -120,13 +137,17 @@ function serializeDocumentTypeNode(documentType: DocumentType): DocumentTypeNode
  * - fullscreen mode
  */
 
-function serializeElementNode(element: Element, options: SerializeOptions): ElementNode | undefined {
+function serializeElementNode(
+  element: Element,
+  parentNodePrivacyLevel: ParentNodePrivacyLevel,
+  options: SerializeOptions
+): ElementNode | undefined {
   const tagName = getValidTagName(element.tagName)
   const isSVG = isSVGElement(element) || undefined
 
   // For performance reason, we don't use getNodePrivacyLevel directly: we leverage the
   // parentNodePrivacyLevel option to avoid iterating over all parents
-  const nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), options.parentNodePrivacyLevel)
+  const nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), parentNodePrivacyLevel)
 
   if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {
     const { width, height } = element.getBoundingClientRect()
@@ -156,19 +177,7 @@ function serializeElementNode(element: Element, options: SerializeOptions): Elem
     // Do not serialize style children as the css rules are already in the _cssText attribute
     tagName !== 'style'
   ) {
-    // OBJECT POOLING OPTIMIZATION:
-    // We should not create a new object systematically as it could impact performances. Try to reuse
-    // the same object as much as possible, and clone it only if we need to.
-    let childNodesSerializationOptions
-    if (options.parentNodePrivacyLevel === nodePrivacyLevel) {
-      childNodesSerializationOptions = options
-    } else {
-      childNodesSerializationOptions = {
-        ...options,
-        parentNodePrivacyLevel: nodePrivacyLevel,
-      }
-    }
-    childNodes = serializeChildNodes(element, childNodesSerializationOptions)
+    childNodes = serializeChildNodes(element, nodePrivacyLevel, options)
   }
 
   return {
@@ -190,8 +199,8 @@ function isSVGElement(el: Element): boolean {
  * for privacy level.
  */
 
-function serializeTextNode(textNode: Text, options: SerializeOptions): TextNode | undefined {
-  const textContent = getTextContent(textNode, options.parentNodePrivacyLevel)
+function serializeTextNode(textNode: Text, parentNodePrivacyLevel: ParentNodePrivacyLevel): TextNode | undefined {
+  const textContent = getTextContent(textNode, parentNodePrivacyLevel)
   if (textContent === undefined) {
     return
   }

packages/rum/src/domain/record/trackers/trackMutation.ts

@@ -240,9 +240,8 @@ function processChildListMutations(
     }
 
     const serializationStart = timeStampNow()
-    const serializedNode = serializeNodeWithId(node, {
+    const serializedNode = serializeNodeWithId(node, parentNodePrivacyLevel, {
       serializedNodeIds,
-      parentNodePrivacyLevel,
       serializationContext,
       configuration,
       scope,