Created streamToView and added tests.

Author: BeltranBulbarellaDD

packages/rum-core/src/domain/assembly.ts

@@ -12,13 +12,14 @@ import {
 } from '@datadog/browser-core'
 import type { RumEventDomainContext } from '../domainContext.types'
 import { RumEventType } from '../rawRumEvent.types'
-import type { RumEvent, RumViewEvent } from '../rumEvent.types'
+import type { RumEvent } from '../rumEvent.types'
 import type { LifeCycle } from './lifeCycle'
 import { LifeCycleEventType } from './lifeCycle'
 import type { RumConfiguration } from './configuration'
 import type { ModifiableFieldPaths } from './limitModification'
 import { limitModification } from './limitModification'
 import type { Hooks } from './hooks'
+import { mapStreamToView } from './streamToView'
 
 const VIEW_MODIFIABLE_FIELD_PATHS: ModifiableFieldPaths = {
   'view.name': 'string',
@@ -114,7 +115,7 @@ export function startRumAssembly(
     LifeCycleEventType.RAW_RUM_EVENT_COLLECTED,
     ({ startTime, duration, rawRumEvent, domainContext }) => {
       const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, {
-        eventType: rawRumEvent.type === 'stream' ? 'view' : rawRumEvent.type,
+        eventType: rawRumEvent.type === RumEventType.STREAM ? RumEventType.VIEW : rawRumEvent.type,
         startTime,
         duration,
       })!
@@ -132,35 +133,10 @@ export function startRumAssembly(
           delete serverRumEvent.context
         }
 
-        if (rawRumEvent.type === 'stream') {
-          const streamEvent = {
-            ...(serverRumEvent as RumViewEvent),
-            _dd: {
-              ...serverRumEvent._dd,
-              document_version: serverRumEvent.stream?.document_version,
-            },
-            stream: {
-              ...serverRumEvent.stream,
-              time_spent: undefined,
-            },
-            view: {
-              ...serverRumEvent.view,
-              id: serverRumEvent.stream?.id,
-              action: {
-                count: 0,
-              },
-              error: {
-                count: 0,
-              },
-              resource: {
-                count: 0,
-              },
-              time_spent: serverRumEvent.stream?.time_spent,
-            },
-            type: 'view',
-          }
+        if (rawRumEvent.type === RumEventType.STREAM) {
+          const streamEvent = mapStreamToView(serverRumEvent)
 
-          lifeCycle.notify(LifeCycleEventType.RUM_EVENT_COLLECTED, streamEvent as RumEvent & Context)
+          lifeCycle.notify(LifeCycleEventType.RUM_EVENT_COLLECTED, streamEvent)
         } else {
           lifeCycle.notify(LifeCycleEventType.RUM_EVENT_COLLECTED, serverRumEvent)
         }

packages/rum-core/src/domain/streamToView.spec.ts

@@ -0,0 +1,56 @@
+import type { Context } from '@datadog/browser-core'
+import { RumEventType } from '../rawRumEvent.types'
+import type { RumEvent, RumViewEvent } from '../rumEvent.types'
+import { mapStreamToView } from './streamToView'
+
+describe('mapStreamToView', () => {
+  it('maps stream to view correctly', () => {
+    const input = {
+      type: RumEventType.STREAM,
+      stream: {
+        id: 'stream-id-456',
+        document_version: 25,
+        time_spent: 3_000_000_000,
+      },
+      view: { id: 'original-view-id', url: '/test-page' },
+      _dd: { replay: true },
+      context: { foo: 'bar' },
+    } as unknown as RumEvent & Context
+
+    const out = mapStreamToView(input) as unknown as RumViewEvent & Context
+
+    expect(out.type).toBe(RumEventType.VIEW)
+    expect(out._dd.document_version).toBe(25)
+    expect(out.view.id).toBe('stream-id-456')
+    expect(out.view.time_spent).toBe(3_000_000_000)
+    expect(out.stream!.time_spent).toBeUndefined()
+    expect(out.view.action.count).toBe(0)
+    expect(out.view.error.count).toBe(0)
+    expect(out.view.resource.count).toBe(0)
+  })
+
+  it('does not mutate the input', () => {
+    const input = {
+      type: RumEventType.STREAM,
+      stream: { id: 'x', document_version: 1, time_spent: 1 },
+      view: { id: 'y' },
+    } as unknown as RumEvent & Context
+    const snapshot = JSON.parse(JSON.stringify(input))
+
+    mapStreamToView(input)
+
+    expect(input).toEqual(snapshot)
+  })
+
+  it('handles missing fields gracefully', () => {
+    const out = mapStreamToView({
+      type: RumEventType.STREAM,
+      stream: { id: 'only-id' },
+      view: {},
+    } as unknown as RumEvent & Context) as RumViewEvent
+
+    expect(out.view.id).toBe('only-id')
+    expect(out._dd?.document_version).toBeUndefined()
+    expect(out.view.time_spent).toBeUndefined()
+  })
+})

packages/rum-core/src/domain/streamToView.ts

@@ -0,0 +1,34 @@
+import type { Context } from '@datadog/browser-core'
+import { RumEventType } from '../rawRumEvent.types'
+import type { RumEvent, RumViewEvent } from '../rumEvent.types'
+
+export function mapStreamToView(serverRumEvent: RumEvent & Context): RumEvent & Context {
+  const streamEvent = {
+    ...(serverRumEvent as RumViewEvent),
+    _dd: {
+      ...serverRumEvent._dd,
+      document_version: serverRumEvent.stream?.document_version,
+    },
+    stream: {
+      ...serverRumEvent.stream,
+      time_spent: undefined,
+    },
+    view: {
+      ...serverRumEvent.view,
+      id: serverRumEvent.stream?.id,
+      action: {
+        count: 0,
+      },
+      error: {
+        count: 0,
+      },
+      resource: {
+        count: 0,
+      },
+      time_spent: serverRumEvent.stream?.time_spent,
+    },
+    type: RumEventType.VIEW,
+  }
+
+  return streamEvent as RumEvent & Context
+}

packages/rum-core/src/domain/trackEventCounts.ts

@@ -30,7 +30,7 @@ export function trackEventCounts({
   }
 
   const subscription = lifeCycle.subscribe(LifeCycleEventType.RUM_EVENT_COLLECTED, (event): void => {
-    if (event.type === 'view' || event.type === 'vital' || !isChildEvent(event) || ['stream'].includes(event.type)) {
+    if (event.type === RumEventType.VIEW || event.type === RumEventType.VITAL || !isChildEvent(event)) {
       return
     }
     switch (event.type) {