🎨 [PANA-7353] Clean up naming in recording code (#4628)

Author: sethfowler-datadog

packages/rum/src/domain/record/internalApi.ts

@@ -7,13 +7,8 @@ import type { RecordingScope } from './recordingScope'
 import { createRecordingScope } from './recordingScope'
 import { createElementsScrollPositions } from './elementsScrollPositions'
 import type { EmitRecordCallback } from './record.types'
-import type { ChangeSerializationTransaction } from './serialization'
-import {
-  createRootInsertionCursor,
-  SerializationKind,
-  serializeChangesInTransaction,
-  serializeNodeAsChange,
-} from './serialization'
+import type { SerializationTransaction } from './serialization'
+import { createRootInsertionCursor, SerializationKind, serializeInTransaction, serializeNode } from './serialization'
 
 /**
  * Take a full snapshot of the document, generating the same records that the browser SDK
@@ -57,19 +52,19 @@ export function takeNodeSnapshot(
     nodeSnapshotRecord = record
   }
 
-  serializeChangesInTransaction(
+  serializeInTransaction(
     SerializationKind.INITIAL_FULL_SNAPSHOT,
     emitRecord,
     noop,
     createTemporaryRecordingScope(configuration),
     timeStampNow(),
-    (transaction: ChangeSerializationTransaction): void => {
+    (transaction: SerializationTransaction): void => {
       const privacyLevel = getNodePrivacyLevel(node, transaction.scope.configuration.defaultPrivacyLevel)
       if (privacyLevel === NodePrivacyLevel.HIDDEN || privacyLevel === NodePrivacyLevel.IGNORE) {
         return
       }
       const cursor = createRootInsertionCursor(transaction.scope.nodeIds)
-      serializeNodeAsChange(cursor, node, privacyLevel, transaction)
+      serializeNode(cursor, node, privacyLevel, transaction)
     }
   )
 

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

@@ -2,11 +2,11 @@ export type { ChangeDecoder } from './changeDecoder'
 export { createChangeDecoder } from './changeDecoder'
 export { createChildInsertionCursor, createRootInsertionCursor } from './insertionCursor'
 export { getElementInputValue } from './serializationUtils'
-export { serializeFullSnapshotAsChange } from './serializeFullSnapshotAsChange'
-export { serializeMutationsAsChange } from './serializeMutationsAsChange'
-export { serializeNodeAsChange } from './serializeNodeAsChange'
+export { serializeFullSnapshot } from './serializeFullSnapshot'
+export { serializeMutations } from './serializeMutations'
+export { serializeNode } from './serializeNode'
 export { serializeAttribute } from './serializeAttribute'
 export { createSerializationStats, updateSerializationStats, aggregateSerializationStats } from './serializationStats'
 export type { SerializationMetric, SerializationStats } from './serializationStats'
-export { serializeChangesInTransaction, SerializationKind } from './serializationTransaction'
-export type { ChangeSerializationTransaction } from './serializationTransaction'
+export { serializeInTransaction, SerializationKind } from './serializationTransaction'
+export type { SerializationTransaction } from './serializationTransaction'

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

@@ -33,16 +33,19 @@ export const enum SerializationKind {
 
 type AddNodeParams<NodeChange extends AddNodeChange> = NodeChange extends [any, any, ...infer Params] ? Params : never
 
-export type ChangeSerializationTransactionCallback = (transaction: ChangeSerializationTransaction) => void
+export type SerializationTransactionCallback = (transaction: SerializationTransaction) => void
 
 /**
- * ChangeSerializationTransaction is used to build and emit a BrowserChangeRecord
- * containing a serialized snapshot of the DOM. Unlike SerializationTransaction, it
- * doesn't support emitting arbitrary BrowserRecords; instead, the builder methods it
- * exposes are used to construct a single BrowserChangeRecord which is emitted at the end
- * of the transaction.
+ * SerializationTransaction is used to build and emit a `BrowserChangeRecord` containing a
+ * serialized snapshot of the DOM. The term "transaction" is used because all the changes
+ * in a serialization transaction are applied together, atomically. A serialization
+ * transaction is thus always associated with a single timestamp.
+ *
+ * To use `SerializationTransaction`, call the builder methods it exposes to add changes
+ * to the transaction. At the end of the transaction, the changes will be combined into a
+ * single `BrowserChangeRecord` and emitted.
  */
-export interface ChangeSerializationTransaction {
+export interface SerializationTransaction {
   /**
    * Add a metric to the transaction's statistics. The aggregated statistics will be
    * emitted when the transaction ends.
@@ -101,18 +104,18 @@ export interface ChangeSerializationTransaction {
   scope: RecordingScope
 }
 
-export function serializeChangesInTransaction(
+export function serializeInTransaction(
   kind: SerializationKind,
   emitRecord: EmitRecordCallback,
   emitStats: EmitStatsCallback,
   scope: RecordingScope,
   timestamp: TimeStamp,
-  serialize: ChangeSerializationTransactionCallback
+  serialize: SerializationTransactionCallback
 ): void {
   const encoder = createChangeEncoder(scope.stringIds)
   const stats = createSerializationStats()
 
-  const transaction: ChangeSerializationTransaction = {
+  const transaction: SerializationTransaction = {
     addMetric(metric: keyof SerializationStats, value: number): void {
       updateSerializationStats(stats, metric, value)
     },

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

@@ -12,7 +12,7 @@ import { appendElement } from '@datadog/browser-rum-core/test'
 import { createSerializationTransactionForTesting } from '../test/serialization.specHelper'
 import type { ScrollPositions } from '../elementsScrollPositions'
 import { getCssRulesString, serializeDOMAttributes, serializeVirtualAttributes } from './serializeAttributes'
-import type { ChangeSerializationTransaction } from './serializationTransaction'
+import type { SerializationTransaction } from './serializationTransaction'
 import { SerializationKind } from './serializationTransaction'
 import type { VirtualAttributes } from './serialization.types'
 import type { SerializationMetric, SerializationStats } from './serializationStats'
@@ -30,7 +30,7 @@ const PRIVACY_LEVELS = Object.keys({
 } satisfies Record<NodePrivacyLevel, true>) as NodePrivacyLevel[]
 
 describe('serializeDOMAttributes', () => {
-  let transaction: ChangeSerializationTransaction
+  let transaction: SerializationTransaction
 
   beforeEach(() => {
     transaction = createSerializationTransactionForTesting()
@@ -332,7 +332,7 @@ describe('serializeDOMAttributes', () => {
 
 describe('serializeVirtualAttributes', () => {
   let stats: SerializationStats
-  let transaction: ChangeSerializationTransaction
+  let transaction: SerializationTransaction
 
   beforeEach(() => {
     stats = createSerializationStats()

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

@@ -2,14 +2,14 @@ import { NodePrivacyLevel, shouldMaskNode } from '@datadog/browser-rum-core'
 import { isSafari } from '@datadog/browser-core'
 import { getElementInputValue, normalizedTagName, switchToAbsoluteUrl } from './serializationUtils'
 import { serializeAttribute } from './serializeAttribute'
-import type { ChangeSerializationTransaction } from './serializationTransaction'
+import type { SerializationTransaction } from './serializationTransaction'
 import { SerializationKind } from './serializationTransaction'
 import type { VirtualAttributes } from './serialization.types'
 
 export function serializeAttributes(
   element: Element,
   nodePrivacyLevel: NodePrivacyLevel,
-  transaction: ChangeSerializationTransaction
+  transaction: SerializationTransaction
 ): Record<string, number | string> {
   return {
     ...serializeDOMAttributes(element, nodePrivacyLevel, transaction),
@@ -20,7 +20,7 @@ export function serializeAttributes(
 export function serializeDOMAttributes(
   element: Element,
   nodePrivacyLevel: NodePrivacyLevel,
-  transaction: ChangeSerializationTransaction
+  transaction: SerializationTransaction
 ): Record<string, string> {
   if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {
     return {}
@@ -83,7 +83,7 @@ export function serializeDOMAttributes(
 export function serializeVirtualAttributes(
   element: Element,
   nodePrivacyLevel: NodePrivacyLevel,
-  transaction: ChangeSerializationTransaction
+  transaction: SerializationTransaction
 ): VirtualAttributes {
   if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {
     return {}

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

@@ -0,0 +1,26 @@
+import type { TimeStamp } from '@datadog/browser-core'
+import type { EmitRecordCallback, EmitStatsCallback } from '../record.types'
+import type { RecordingScope } from '../recordingScope'
+import { serializeInTransaction } from './serializationTransaction'
+import type { SerializationTransaction, SerializationKind } from './serializationTransaction'
+import { serializeNode } from './serializeNode'
+import { createRootInsertionCursor } from './insertionCursor'
+
+export function serializeFullSnapshot(
+  timestamp: TimeStamp,
+  kind: SerializationKind,
+  document: Document,
+  emitRecord: EmitRecordCallback,
+  emitStats: EmitStatsCallback,
+  scope: RecordingScope
+): void {
+  scope.resetIds()
+  serializeInTransaction(kind, emitRecord, emitStats, scope, timestamp, (transaction: SerializationTransaction) => {
+    serializeNode(
+      createRootInsertionCursor(scope.nodeIds),
+      document,
+      scope.configuration.defaultPrivacyLevel,
+      transaction
+    )
+  })
+}

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

@@ -12,34 +12,34 @@ import type { AttributeChange } from '../../../types'
 import type { RecordingScope } from '../recordingScope'
 import type { EmitRecordCallback, EmitStatsCallback } from '../record.types'
 import type { NodeId, NodeIds } from '../itemIds'
-import type { ChangeSerializationTransaction } from './serializationTransaction'
-import { SerializationKind, serializeChangesInTransaction } from './serializationTransaction'
-import { serializeNodeAsChange } from './serializeNodeAsChange'
+import type { SerializationTransaction } from './serializationTransaction'
+import { SerializationKind, serializeInTransaction } from './serializationTransaction'
+import { serializeNode } from './serializeNode'
 import { createChildInsertionCursor } from './insertionCursor'
 import { getElementInputValue } from './serializationUtils'
 import { serializeAttribute } from './serializeAttribute'
 
-export function serializeMutationsAsChange(
+export function serializeMutations(
   timestamp: TimeStamp,
   mutations: RumMutationRecord[],
   emitRecord: EmitRecordCallback,
   emitStats: EmitStatsCallback,
   scope: RecordingScope
 ): void {
-  serializeChangesInTransaction(
+  serializeInTransaction(
     SerializationKind.INCREMENTAL_SNAPSHOT,
     emitRecord,
     emitStats,
     scope,
     timestamp,
-    (transaction: ChangeSerializationTransaction) => processMutations(mutations, transaction)
+    (transaction: SerializationTransaction) => processMutations(mutations, transaction)
   )
 }
 
 type AttributeName = string
 type OldValue = string | null
 
-function processMutations(mutations: RumMutationRecord[], transaction: ChangeSerializationTransaction): void {
+function processMutations(mutations: RumMutationRecord[], transaction: SerializationTransaction): void {
   const addedNodes = new Set<Node>()
   const attributeMutations = new Map<Element, Map<AttributeName, OldValue>>()
   const characterDataMutations = new Map<Node, OldValue>()
@@ -101,7 +101,7 @@ function processMutations(mutations: RumMutationRecord[], transaction: ChangeSer
   processAttributeMutations(attributeMutations, firstNewNodeId, nodePrivacyLevelCache, transaction)
 }
 
-function processRemovedNodes(nodes: Set<Node>, transaction: ChangeSerializationTransaction): void {
+function processRemovedNodes(nodes: Set<Node>, transaction: SerializationTransaction): void {
   const nodeIds = transaction.scope.nodeIds
 
   for (const node of nodes) {
@@ -130,7 +130,7 @@ function processRemovedNodes(nodes: Set<Node>, transaction: ChangeSerializationT
 function processAddedNodes(
   nodes: Set<Node>,
   nodePrivacyLevelCache: NodePrivacyLevelCache,
-  transaction: ChangeSerializationTransaction
+  transaction: SerializationTransaction
 ): void {
   const nodeIds = transaction.scope.nodeIds
 
@@ -164,7 +164,7 @@ function processAddedNodes(
 
     const nextSiblingId = getNextSiblingId(node, nodeIds)
 
-    serializeNodeAsChange(
+    serializeNode(
       createChildInsertionCursor(parentId, nextSiblingId, nodeIds),
       node,
       parentNodePrivacyLevel,
@@ -177,7 +177,7 @@ function processCharacterDataMutations(
   mutations: Map<Node, OldValue>,
   firstNewNodeId: NodeId,
   nodePrivacyLevelCache: NodePrivacyLevelCache,
-  transaction: ChangeSerializationTransaction
+  transaction: SerializationTransaction
 ): void {
   const nodeIds = transaction.scope.nodeIds
 
@@ -223,7 +223,7 @@ function processAttributeMutations(
   mutations: Map<Element, Map<AttributeName, OldValue>>,
   firstNewNodeId: NodeId,
   nodePrivacyLevelCache: NodePrivacyLevelCache,
-  transaction: ChangeSerializationTransaction
+  transaction: SerializationTransaction
 ): void {
   const nodeIds = transaction.scope.nodeIds