✨ [RUM-10144] delay assembly

Author: BenoitZugmeyer

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

@@ -478,6 +478,34 @@ describe('rum assembly', () => {
     })
   })
 
+  describe('global context', () => {
+    it('applies global context to events', async () => {
+      const { lifeCycle, globalContext, getRumEvents } = setupAssemblyTestWithDefaults()
+
+      globalContext.setContext({ foo: 'bar' })
+
+      notifyRawRumEvent(lifeCycle, {
+        rawRumEvent: createRawRumEvent(RumEventType.ACTION),
+      })
+
+      const rumEvents = await getRumEvents()
+      expect(rumEvents[0].context).toEqual({ foo: 'bar' })
+    })
+
+    it('applies global context to events generated before the global context is set', async () => {
+      const { lifeCycle, globalContext, getRumEvents } = setupAssemblyTestWithDefaults()
+
+      notifyRawRumEvent(lifeCycle, {
+        rawRumEvent: createRawRumEvent(RumEventType.ACTION),
+      })
+
+      globalContext.setContext({ foo: 'bar' })
+
+      const rumEvents = await getRumEvents()
+      expect(rumEvents[0].context).toEqual({ foo: 'bar' })
+    })
+  })
+
   describe('event generation condition', () => {
     it('when tracked, it should generate event', async () => {
       const { lifeCycle, getRumEvents } = setupAssemblyTestWithDefaults()

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

@@ -6,13 +6,14 @@ import {
   createEventRateLimiter,
   isExperimentalFeatureEnabled,
   ExperimentalFeature,
+  BufferedObservable,
   HookNames,
   DISCARDED,
 } from '@datadog/browser-core'
 import type { RumEventDomainContext } from '../domainContext.types'
 import { RumEventType } from '../rawRumEvent.types'
 import type { RumEvent } from '../rumEvent.types'
-import type { LifeCycle } from './lifeCycle'
+import type { LifeCycle, RawRumEventCollectedData } from './lifeCycle'
 import { LifeCycleEventType } from './lifeCycle'
 import type { RumConfiguration } from './configuration'
 import type { ModifiableFieldPaths } from './limitModification'
@@ -34,6 +35,10 @@ const ROOT_MODIFIABLE_FIELD_PATHS: ModifiableFieldPaths = {
   version: 'string',
 }
 
+// The size of the buffer for events that are collected just after starting the assembly. This is a
+// bit arbitrary, but should be large enough to avoid dropping events in most cases.
+const BUFFERED_EVENT_SIZE = 100
+
 let modifiableFieldPathsByEvent: { [key in RumEventType]: ModifiableFieldPaths }
 
 export function startRumAssembly(
@@ -102,30 +107,32 @@ export function startRumAssembly(
     ),
   }
 
-  lifeCycle.subscribe(
-    LifeCycleEventType.RAW_RUM_EVENT_COLLECTED,
-    ({ startTime, duration, rawRumEvent, domainContext, customerContext }) => {
-      const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, {
-        eventType: rawRumEvent.type,
-        startTime,
-        duration,
-      })!
+  const observable = new BufferedObservable<RawRumEventCollectedData>(BUFFERED_EVENT_SIZE)
 
-      if (defaultRumEventAttributes === DISCARDED) {
-        return
-      }
+  lifeCycle.subscribe(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, (data) => observable.notify(data))
+
+  observable.subscribe(({ startTime, duration, rawRumEvent, domainContext, customerContext }) => {
+    const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, {
+      eventType: rawRumEvent.type,
+      startTime,
+      duration,
+    })!
+
+    if (defaultRumEventAttributes === DISCARDED) {
+      return
+    }
 
-      const serverRumEvent = combine(defaultRumEventAttributes, { context: customerContext }, rawRumEvent) as RumEvent &
-        Context
+    const serverRumEvent = combine(defaultRumEventAttributes, { context: customerContext }, rawRumEvent) as RumEvent &
+      Context
 
-      if (shouldSend(serverRumEvent, configuration.beforeSend, domainContext, eventRateLimiters)) {
-        if (isEmptyObject(serverRumEvent.context!)) {
-          delete serverRumEvent.context
-        }
-        lifeCycle.notify(LifeCycleEventType.RUM_EVENT_COLLECTED, serverRumEvent)
+    if (shouldSend(serverRumEvent, configuration.beforeSend, domainContext, eventRateLimiters)) {
+      if (isEmptyObject(serverRumEvent.context!)) {
+        delete serverRumEvent.context
       }
+      lifeCycle.notify(LifeCycleEventType.RUM_EVENT_COLLECTED, serverRumEvent)
     }
-  )
+  })
+  observable.unbuffer()
 }
 
 function shouldSend(