fix: Ensure event buffer always exists (#1452)

Author: metal-messiah

src/features/soft_navigations/aggregate/index.js

@@ -26,15 +26,7 @@ export class Aggregate extends AggregateBase {
       if (agentRef.runtime.session?.isNew) this.initialPageLoadInteraction.customAttributes.isFirstOfSession = true // mark the hard page load as first of its session
       this.initialPageLoadInteraction.forceSave = true // unless forcibly ignored, iPL always finish by default
       const ixn = this.initialPageLoadInteraction
-      /** this.events (ixns to harvest) has already been set up, use it immediately */
-      if (this.interactionsToHarvest) this.interactionsToHarvest.add(ixn)
-      else {
-        /** this.events (ixns to harvest) hasnt been initialized yet... wait for it */
-        this.ee.on('entity-added', () => {
-          this.interactionsToHarvest = this.events
-          this.interactionsToHarvest.add(ixn)
-        })
-      }
+      this.interactionsToHarvest.add(ixn)
       this.initialPageLoadInteraction = null
     })
     timeToFirstByte.subscribe(({ attrs }) => {

src/features/utils/aggregate-base.js

@@ -34,11 +34,13 @@ export class AggregateBase extends FeatureBase {
     this.harvestOpts = {} // features aggregate classes can define custom opts for when their harvest is called
 
     const agentEntityGuid = this.agentRef?.runtime?.appMetadata?.agents?.[0]?.entityGuid
-    if (agentEntityGuid) {
-      this.#setupEventStore(agentEntityGuid) // if there's no entity guid, wont dont anything, and will wait for rum flags
-    } else {
+    this.#setupEventStore(agentEntityGuid)
+    if (!agentEntityGuid) {
+      /** wait for the entity guid from the rum response and use to it to further configure things to set the default entity to share an indexed entity with entityGuid */
       this.ee.on('entity-added', entity => {
-        this.#setupEventStore(entity.entityGuid)
+        // not all event managers have this fn, like ST and SR
+        // this allows the lookup to work for the default and an entityGuid without creating two separate buffers
+        this.events?.setEventStore?.(entity.entityGuid)
       })
     }
   }
@@ -49,7 +51,7 @@ export class AggregateBase extends FeatureBase {
    * @returns {void}
    */
   #setupEventStore (entityGuid) {
-    if (this.events || !entityGuid) return
+    if (this.events) return
     switch (this.featureName) {
     // SessionTrace + Replay have their own storage mechanisms.
       case FEATURE_NAMES.sessionTrace:

src/features/utils/event-store-manager.js

@@ -4,7 +4,9 @@
  */
 import { dispatchGlobalEvent } from '../../common/dispatch/global-event'
 import { activatedFeatures } from '../../common/util/feature-flags'
+import { isContainerAgentTarget } from '../../common/util/target'
 
+const DEFAULT_KEY = 'NR_CONTAINER_AGENT' // this is the default entity guid used for the default storage instance
 /**
  * This layer allows multiple browser entity apps, or "target", to each have their own segregated storage instance.
  * The purpose is so the harvester can send data to different apps within the same agent. Each feature should have a manager if it needs this capability.
@@ -13,27 +15,38 @@ export class EventStoreManager {
   /**
    * @param {object} agentRef - reference to base agent class
    * @param {EventBuffer|EventAggregator} storageClass - the type of storage to use in this manager; 'EventBuffer' (1), 'EventAggregator' (2)
+   * @param {string} [defaultEntityGuid] - the entity guid to use as the default storage instance; if not provided, a new one is created
+   * @param {string} featureName - the name of the feature this manager is for; used for event dispatching
    */
   constructor (agentRef, storageClass, defaultEntityGuid, featureName) {
     this.agentRef = agentRef
     this.entityManager = agentRef.runtime.entityManager
     this.StorageClass = storageClass
-    this.appStorageMap = new Map()
-    this.defaultEntity = this.#getEventStore(defaultEntityGuid)
+    this.appStorageMap = new Map([[DEFAULT_KEY, new this.StorageClass()]])
     this.featureName = featureName
+    this.setEventStore(defaultEntityGuid)
   }
 
   /**
    * Always returns a storage instance.  Creates one if one does not exist.  If a lookup is not provided, uses the DEFAULT namespace
    * @param {string=} targetEntityGuid the lookup
    * @returns {*} ALWAYS returns a storage instance
    */
-  #getEventStore (targetEntityGuid) {
-    if (!targetEntityGuid) return this.defaultEntity
-    if (!this.appStorageMap.has(targetEntityGuid)) this.appStorageMap.set(targetEntityGuid, new this.StorageClass())
+  #getEventStore (targetEntityGuid = DEFAULT_KEY) {
+    if (!this.appStorageMap.has(targetEntityGuid)) this.setEventStore(targetEntityGuid)
     return this.appStorageMap.get(targetEntityGuid)
   }
 
+  setEventStore (targetEntityGuid) {
+    /** we should already have an event store for the default */
+    if (!targetEntityGuid) return
+    /** if the target is the container agent, SHARE the default storage -- otherwise create a new event store */
+    const eventStorage = (isContainerAgentTarget(this.entityManager.get(targetEntityGuid), this.agentRef))
+      ? this.appStorageMap.get(DEFAULT_KEY)
+      : new this.StorageClass()
+    this.appStorageMap.set(targetEntityGuid, eventStorage)
+  }
+
   // This class must contain an union of all methods from all supported storage classes and conceptualize away the target app argument.
 
   /**

tests/components/ajax/aggregate.test.js

@@ -166,9 +166,10 @@ describe('prepareHarvest', () => {
     })
   })
 
-  test('correctly exits if maxPayload is too small', () => {
-    ajaxAggregate.events.defaultEntity.maxPayloadSize = 10 // this is too small for any AJAX payload to fit in
-    for (let callNo = 0; callNo < 10; callNo++) ajaxAggregate.ee.emit('xhr', ajaxArguments, context)
+  test('correctly exits if maxPayload is too small', async () => {
+    for (let callNo = 0; callNo < 10; callNo++) {
+      ajaxAggregate.ee.emit('xhr', [{ ...ajaxArguments[0], pathname: 'x'.repeat(1000000) }, ...ajaxArguments], context)
+    }
 
     const serializedPayload = ajaxAggregate.makeHarvestPayload(false)
     expect(serializedPayload).toBeUndefined() // payload that are each too small for limit will be dropped

tests/unit/features/utils/event-store-manager.test.js

@@ -9,7 +9,7 @@ const entity = { entityGuid, ...info }
 const entityManager = new EntityManager({ info, ee: { emit: jest.fn() } })
 entityManager.setDefaultEntity(entity)
 entityManager.set(entityGuid, entity)
-const mockAgentRef = { runtime: { entityManager, appMetadata: { agents: [{ entityGuid }] } } }
+const mockAgentRef = { info, runtime: { entityManager, appMetadata: { agents: [{ entityGuid }] } } }
 describe('EventStoreManager', () => {
   test('uses EventBuffer class when storageChoice is EventBuffer', () => {
     const store = new EventStoreManager(mockAgentRef, EventBuffer, mockAgentRef.runtime.appMetadata.agents[0].entityGuid, 'test')
@@ -95,15 +95,15 @@ describe('EventStoreManager', () => {
   })
 
   test('isEmpty checks ALL storages when target is not provided', () => {
-    const tgt1 = { name: 'myTarget' }
+    const tgt1 = 'myTarget'
     const store = new EventStoreManager(mockAgentRef, EventBuffer, mockAgentRef.runtime.appMetadata.agents[0].entityGuid, 'test')
     expect(store.isEmpty()).toBeTruthy()
     store.add('myEvent', tgt1)
     expect(store.isEmpty()).toBeFalsy()
     store.clear()
     expect(store.isEmpty()).toBeTruthy()
 
-    store.add('evt2', { name: 'otherTarget' })
+    store.add('evt2', 'otherTarget')
     expect(store.isEmpty()).toBeFalsy()
     expect(store.isEmpty(undefined, tgt1)).toBeTruthy()
     store.add('evt1', tgt1)