⚗️ Implement partial view updates at transport layer

When partial_view_updates is enabled, startRumBatch intercepts assembled view
events and sends view_update diffs instead of full views for intermediate updates.

Key design: diff runs post-assembly so beforeSend always sees full view events
(backward-compatible). view_update events intentionally bypass the assembly
pipeline — they are a bandwidth optimization, not a customer-visible event type.

- computeAssembledViewDiff: diffs two assembled view events, always including
  required routing fields (view.id, view.url, _dd.document_version, format_version)
- Routing state machine: handles new view / view-end / checkpoint / diff cases
- view-end events (is_active: false) always sent as full view
- Full view checkpoint every 100 updates for backend recovery
- Exclude view_update from trackEventCounts and assembly beforeSend guard
- Add E2E tests covering all routing cases

Author: mormubis

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

@@ -372,27 +372,31 @@ describe('rum assembly', () => {
   describe('service and version', () => {
     const extraConfigurationOptions = { service: 'default-service', version: 'default-version' }
 
-    Object.values(RumEventType).forEach((eventType) => {
-      it(`should be modifiable for ${eventType}`, () => {
-        const { lifeCycle, serverRumEvents } = setupAssemblyTestWithDefaults({
-          partialConfiguration: {
-            ...extraConfigurationOptions,
-            beforeSend: (event) => {
-              event.service = 'bar'
-              event.version = '0.2.0'
+    // view_update events bypass the assembly pipeline (created post-assembly in startRumBatch)
+    // and are intentionally not modifiable via beforeSend.
+    Object.values(RumEventType)
+      .filter((eventType) => eventType !== RumEventType.VIEW_UPDATE)
+      .forEach((eventType) => {
+        it(`should be modifiable for ${eventType}`, () => {
+          const { lifeCycle, serverRumEvents } = setupAssemblyTestWithDefaults({
+            partialConfiguration: {
+              ...extraConfigurationOptions,
+              beforeSend: (event) => {
+                event.service = 'bar'
+                event.version = '0.2.0'
 
-              return true
+                return true
+              },
             },
-          },
-        })
+          })
 
-        notifyRawRumEvent(lifeCycle, {
-          rawRumEvent: createRawRumEvent(eventType),
+          notifyRawRumEvent(lifeCycle, {
+            rawRumEvent: createRawRumEvent(eventType),
+          })
+          expect((serverRumEvents[0] as RumResourceEvent).service).toBe('bar')
+          expect((serverRumEvents[0] as RumResourceEvent).version).toBe('0.2.0')
         })
-        expect((serverRumEvents[0] as RumResourceEvent).service).toBe('bar')
-        expect((serverRumEvents[0] as RumResourceEvent).version).toBe('0.2.0')
       })
-    })
 
     it('should be added to the event as ddtags', () => {
       const { lifeCycle, serverRumEvents } = setupAssemblyTestWithDefaults({

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

@@ -49,6 +49,10 @@ export function startRumAssembly(
       ...VIEW_MODIFIABLE_FIELD_PATHS,
       ...ROOT_MODIFIABLE_FIELD_PATHS,
     },
+    // view_update events are created post-assembly in startRumBatch.ts and never go through
+    // this pipeline — they intentionally bypass beforeSend. This entry is required by the
+    // exhaustive type but is never reached in practice.
+    [RumEventType.VIEW_UPDATE]: {},
     [RumEventType.ERROR]: {
       'error.message': 'string',
       'error.stack': 'string',

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)) {
+    if (event.type === 'view' || event.type === 'view_update' || event.type === 'vital' || !isChildEvent(event)) {
       return
     }
     switch (event.type) {

packages/rum-core/src/transport/startRumBatch.spec.ts

@@ -0,0 +1,227 @@
+import { ExperimentalFeature, addExperimentalFeatures, isExperimentalFeatureEnabled } from '@datadog/browser-core'
+import { resetExperimentalFeatures } from '@datadog/browser-core/src/tools/experimentalFeatures'
+import { registerCleanupTask } from '@datadog/browser-core/test'
+import type { AssembledRumEvent } from '../rawRumEvent.types'
+import { RumEventType } from '../rawRumEvent.types'
+import { computeAssembledViewDiff, PARTIAL_VIEW_UPDATE_CHECKPOINT_INTERVAL } from './startRumBatch'
+
+function makeAssembledView(overrides: Record<string, unknown> = {}): AssembledRumEvent {
+  return {
+    type: RumEventType.VIEW,
+    date: 1000,
+    application: { id: 'app-1' },
+    session: { id: 'sess-1', type: 'user' },
+    view: {
+      id: 'view-1',
+      name: 'Home',
+      url: '/home',
+      referrer: '',
+      is_active: true,
+      action: { count: 0 },
+      error: { count: 0 },
+      long_task: { count: 0 },
+      resource: { count: 0 },
+      time_spent: 0,
+    },
+    _dd: {
+      document_version: 1,
+      format_version: 2,
+      sdk_name: 'rum',
+      configuration: { start_session_replay_recording_manually: false },
+    },
+    service: 'my-service',
+    version: '1.0.0',
+    ddtags: 'env:prod',
+    source: 'browser',
+    context: {},
+    ...overrides,
+  } as unknown as AssembledRumEvent
+}
+
+describe('computeAssembledViewDiff', () => {
+  it('should return undefined when nothing has changed', () => {
+    const last = makeAssembledView()
+    const current = makeAssembledView({
+      _dd: {
+        document_version: 2,
+        format_version: 2,
+        sdk_name: 'rum',
+        configuration: { start_session_replay_recording_manually: false },
+      },
+    })
+    const result = computeAssembledViewDiff(current, last)
+
+    // Only document_version changed (always required, not a "meaningful change")
+    // view.* unchanged → should return undefined
+    expect(result).toBeUndefined()
+  })
+
+  it('should always include required routing fields', () => {
+    const last = makeAssembledView()
+    const current = makeAssembledView({
+      _dd: {
+        document_version: 2,
+        format_version: 2,
+        sdk_name: 'rum',
+        configuration: { start_session_replay_recording_manually: false },
+      },
+      view: {
+        id: 'view-1',
+        name: 'Home',
+        url: '/home',
+        referrer: '',
+        is_active: true,
+        action: { count: 1 },
+        error: { count: 0 },
+        long_task: { count: 0 },
+        resource: { count: 0 },
+        time_spent: 100,
+      },
+    })
+    const result = computeAssembledViewDiff(current, last)!
+
+    expect(result.type).toBe(RumEventType.VIEW_UPDATE)
+    expect((result as any).application).toEqual({ id: 'app-1' })
+    expect((result as any).session).toEqual({ id: 'sess-1', type: 'user' })
+    expect((result.view as any).id).toBe('view-1')
+    expect((result.view as any).url).toBe('/home')
+    expect((result._dd as any).document_version).toBe(2)
+    expect((result._dd as any).format_version).toBe(2)
+  })
+
+  it('should include only changed view.* fields', () => {
+    const last = makeAssembledView()
+    const current = makeAssembledView({
+      _dd: {
+        document_version: 2,
+        format_version: 2,
+        sdk_name: 'rum',
+        configuration: { start_session_replay_recording_manually: false },
+      },
+      view: {
+        id: 'view-1',
+        name: 'Home',
+        url: '/home',
+        referrer: '',
+        is_active: true,
+        action: { count: 3 },
+        error: { count: 0 },
+        long_task: { count: 0 },
+        resource: { count: 0 },
+        time_spent: 5000,
+      },
+    })
+    const result = computeAssembledViewDiff(current, last)!
+
+    expect((result.view as any).action).toEqual({ count: 3 }) // changed
+    expect((result.view as any).time_spent).toBe(5000) // changed
+    expect((result.view as any).error).toBeUndefined() // unchanged, stripped
+    expect((result.view as any).name).toBeUndefined() // unchanged, stripped
+    expect((result.view as any).url).toBe('/home') // required routing field, always present
+  })
+
+  it('should strip unchanged top-level assembled fields', () => {
+    const last = makeAssembledView({ service: 'svc', version: '1.0.0' })
+    const current = makeAssembledView({
+      _dd: {
+        document_version: 2,
+        format_version: 2,
+        sdk_name: 'rum',
+        configuration: { start_session_replay_recording_manually: false },
+      },
+      view: {
+        id: 'view-1',
+        name: 'Home',
+        url: '/home',
+        referrer: '',
+        is_active: true,
+        action: { count: 1 },
+        error: { count: 0 },
+        long_task: { count: 0 },
+        resource: { count: 0 },
+        time_spent: 100,
+      },
+      service: 'svc',
+      version: '1.0.0',
+    })
+    const result = computeAssembledViewDiff(current, last)!
+
+    expect(result.service).toBeUndefined() // unchanged, stripped
+    expect((result as any).version).toBeUndefined() // unchanged, stripped
+  })
+
+  it('should keep top-level assembled fields that changed', () => {
+    const last = makeAssembledView({ service: 'old-service' })
+    const current = makeAssembledView({
+      _dd: {
+        document_version: 2,
+        format_version: 2,
+        sdk_name: 'rum',
+        configuration: { start_session_replay_recording_manually: false },
+      },
+      view: {
+        id: 'view-1',
+        name: 'Home',
+        url: '/home',
+        referrer: '',
+        is_active: true,
+        action: { count: 1 },
+        error: { count: 0 },
+        long_task: { count: 0 },
+        resource: { count: 0 },
+        time_spent: 100,
+      },
+      service: 'new-service',
+    })
+    const result = computeAssembledViewDiff(current, last)!
+
+    expect(result.service).toBe('new-service')
+  })
+
+  it('should not mutate the input events', () => {
+    const last = makeAssembledView()
+    const current = makeAssembledView({
+      _dd: {
+        document_version: 2,
+        format_version: 2,
+        sdk_name: 'rum',
+        configuration: { start_session_replay_recording_manually: false },
+      },
+      view: {
+        id: 'view-1',
+        name: 'Home',
+        url: '/home',
+        referrer: '',
+        is_active: true,
+        action: { count: 1 },
+        error: { count: 0 },
+        long_task: { count: 0 },
+        resource: { count: 0 },
+        time_spent: 100,
+      },
+    })
+    const currentService = current.service
+    computeAssembledViewDiff(current, last)
+
+    expect(current.service).toBe(currentService)
+  })
+})
+
+describe('startRumBatch partial_view_updates routing', () => {
+  beforeEach(() => {
+    addExperimentalFeatures([ExperimentalFeature.PARTIAL_VIEW_UPDATES])
+    registerCleanupTask(resetExperimentalFeatures)
+  })
+
+  it('PARTIAL_VIEW_UPDATE_CHECKPOINT_INTERVAL should be 100', () => {
+    expect(PARTIAL_VIEW_UPDATE_CHECKPOINT_INTERVAL).toBe(100)
+  })
+
+  it('PARTIAL_VIEW_UPDATES_NO_CHECKPOINT flag should be defined', () => {
+    expect(ExperimentalFeature.PARTIAL_VIEW_UPDATES_NO_CHECKPOINT).toBe('partial_view_updates_no_checkpoint')
+  })
+
+  it('PARTIAL_VIEW_UPDATES_NO_CHECKPOINT flag should be disabled by default', () => {
+    expect(isExperimentalFeatureEnabled(ExperimentalFeature.PARTIAL_VIEW_UPDATES_NO_CHECKPOINT)).toBe(false)
+  })
+})