@newrelic/browser-agent 1.277.0 → 1.278.1

package/src/features/session_replay/shared/recorder.js

@@ -1,7 +1,6 @@
 import { record as recorder } from 'rrweb'
 import { stringify } from '../../../common/util/stringify'
 import { AVG_COMPRESSION, CHECKOUT_MS, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES } from '../constants'
-import { getConfigurationValue } from '../../../common/config/init'
 import { RecorderEvents } from './recorder-events'
 import { MODE } from '../../../common/session/constants'
 import { stylesheetEvaluator } from './stylesheet-evaluator'
@@ -10,6 +9,7 @@ import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { buildNRMetaNode } from './utils'
 import { IDEAL_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
+import { AggregateBase } from '../../utils/aggregate-base'
 
 export class Recorder {
   /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
@@ -36,7 +36,7 @@ export class Recorder {
     /** The parent class that instantiated the recorder */
     this.parent = parent
     /** A flag that can be set to false by failing conversions to stop the fetching process */
-    this.shouldFix = getConfigurationValue(this.parent.agentIdentifier, 'session_replay.fix_stylesheets')
+    this.shouldFix = this.parent.agentRef.init.session_replay.fix_stylesheets
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
     this.stopRecording = () => { /* no-op until set by rrweb initializer */ }
   }
@@ -73,7 +73,7 @@ export class Recorder {
   /** Begin recording using configured recording lib */
   startRecording () {
     this.recording = true
-    const { block_class, ignore_class, mask_text_class, block_selector, mask_input_options, mask_text_selector, mask_all_inputs, inline_images, collect_fonts } = getConfigurationValue(this.parent.agentIdentifier, 'session_replay')
+    const { block_class, ignore_class, mask_text_class, block_selector, mask_input_options, mask_text_selector, mask_all_inputs, inline_images, collect_fonts } = this.parent.agentRef.init.session_replay
     const customMasker = (text, element) => {
       try {
         if (typeof element?.type === 'string' && element.type.toLowerCase() !== 'password' && (element?.dataset?.nrUnmask !== undefined || element?.classList?.contains('nr-unmask'))) return text
@@ -151,7 +151,7 @@ export class Recorder {
   store (event, isCheckout) {
     if (!event) return
 
-    if (!this.parent.scheduler && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1]
+    if (!(this.parent instanceof AggregateBase) && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1]
     else this.currentBufferTarget = this.#events
 
     if (this.parent.blocked) return
@@ -193,8 +193,8 @@ export class Recorder {
     // it will send immediately.  This often happens on the first snapshot, which can be significantly larger than the other payloads.
     if (((event.type === RRWEB_EVENT_TYPES.FullSnapshot && this.currentBufferTarget.hasMeta) || payloadSize > IDEAL_PAYLOAD_SIZE) && this.parent.mode === MODE.FULL) {
       // if we've made it to the ideal size of ~64kb before the interval timer, we should send early.
-      if (this.parent.scheduler) {
-        this.parent.scheduler.runHarvest()
+      if (this.parent instanceof AggregateBase) {
+        this.parent.agentRef.runtime.harvester.triggerHarvestFor(this.parent)
       } else {
         // we are still in "preload" and it triggered a "stop point".  Make a new set, which will get pointed at on next cycle
         this.#preloaded.push(new RecorderEvents())

package/src/features/session_trace/aggregate/index.js

@@ -1,5 +1,4 @@
 import { registerHandler } from '../../../common/event-emitter/register-handler'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { FEATURE_NAME } from '../constants'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { TraceStorage } from './trace/storage'
@@ -7,7 +6,6 @@ import { obj as encodeObj } from '../../../common/url/encode'
 import { globalScope } from '../../../common/constants/runtime'
 import { MODE, SESSION_EVENTS } from '../../../common/session/constants'
 import { applyFnToProps } from '../../../common/util/traverse'
-import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { cleanURL } from '../../../common/url/clean-url'
 
 const ERROR_MODE_SECONDS_WINDOW = 30 * 1000 // sliding window of nodes to track when simply monitoring (but not harvesting) in error mode
@@ -18,8 +16,8 @@ export class Aggregate extends AggregateBase {
 
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
+    this.harvestOpts.raw = true
 
-    this.harvestTimeSeconds = agentRef.init.session_trace.harvestTimeSeconds || 30
     /** Tied to the entitlement flag response from BCS.  Will short circuit operations of the agg if false  */
     this.entitled = undefined
     /** A flag used to decide if the 30 node threshold should be ignored on the first harvest to ensure sending on the first payload */
@@ -28,7 +26,8 @@ export class Aggregate extends AggregateBase {
     this.harvesting = false
     /** TraceStorage is the mechanism that holds, normalizes and aggregates ST nodes.  It will be accessed and purged when harvests occur */
     this.events = new TraceStorage(this)
-    /** This agg needs information about sampling (sts) and entitlements (st) to make the appropriate decisions on running */
+
+    /* This agg needs information about sampling (sts) and entitlements (st) to make the appropriate decisions on running */
     this.waitForFlags(['sts', 'st'])
       .then(([stMode, stEntitled]) => this.initialize(stMode, stEntitled))
   }
@@ -36,7 +35,8 @@ export class Aggregate extends AggregateBase {
   /** Sets up event listeners, and initializes this module to run in the correct "mode".  Can be triggered from a few places, but makes an effort to only set up listeners once */
   initialize (stMode, stEntitled, ignoreSession) {
     this.entitled ??= stEntitled
-    if (this.blocked || !this.entitled) return this.deregisterDrain()
+    if (!this.entitled) this.blocked = true
+    if (this.blocked) return this.deregisterDrain()
 
     if (!this.initialized) {
       this.initialized = true
@@ -55,7 +55,7 @@ export class Aggregate extends AggregateBase {
         // this will only have an effect if ST is NOT already in full mode
         if (this.mode !== MODE.FULL && (sessionState.sessionReplayMode === MODE.FULL || sessionState.sessionTraceMode === MODE.FULL)) this.switchToFull()
         // if another page's session entity has expired, or another page has transitioned to off and this one hasn't... we can just abort straight away here
-        if (this.sessionId !== sessionState.value || (eventType === 'cross-tab' && this.scheduler?.started && sessionState.sessionTraceMode === MODE.OFF)) this.abort(2)
+        if (this.sessionId !== sessionState.value || (eventType === 'cross-tab' && sessionState.sessionTraceMode === MODE.OFF)) this.abort(2)
       })
 
       if (typeof PerformanceNavigationTiming !== 'undefined') {
@@ -76,13 +76,6 @@ export class Aggregate extends AggregateBase {
 
     this.timeKeeper ??= this.agentRef.runtime.timeKeeper
 
-    this.scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-      onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
-      retryDelay: this.harvestTimeSeconds,
-      getPayload: (options) => this.makeHarvestPayload(options.retry),
-      raw: true
-    }, this)
-
     /** The handlers set up by the Inst file */
     registerHandler('bst', (...args) => this.events.storeEvent(...args), this.featureName, this.ee)
     registerHandler('bstResource', (...args) => this.events.storeResources(...args), this.featureName, this.ee)
@@ -92,9 +85,7 @@ export class Aggregate extends AggregateBase {
     registerHandler('trace-jserror', (...args) => this.events.storeErrorAgg(...args), this.featureName, this.ee)
     registerHandler('pvtAdded', (...args) => this.events.processPVT(...args), this.featureName, this.ee)
 
-    /** Only start actually harvesting if running in full mode at init time */
-    if (this.mode === MODE.FULL) this.startHarvesting()
-    else {
+    if (this.mode !== MODE.FULL) {
       /** A separate handler for noticing errors, and switching to "full" mode if running in "error" mode */
       registerHandler('trace-jserror', () => {
         if (this.mode === MODE.ERROR) this.switchToFull()
@@ -104,13 +95,6 @@ export class Aggregate extends AggregateBase {
     this.drain()
   }
 
-  /** This module does not auto harvest by default -- it needs to be kicked off.  Once this method is called, it will then harvest on an interval */
-  startHarvesting () {
-    if (this.scheduler.started || this.blocked) return
-    this.scheduler.runHarvest()
-    this.scheduler.startTimer(this.harvestTimeSeconds)
-  }
-
   preHarvestChecks () {
     if (this.mode !== MODE.FULL) return // only allow harvest if running in full mode
     if (!this.timeKeeper?.ready) return // this should likely never happen, but just to be safe, we should never harvest if we cant correct time
@@ -185,8 +169,8 @@ export class Aggregate extends AggregateBase {
     if (prevMode === MODE.OFF || !this.initialized) return this.initialize(this.mode, this.entitled)
     if (this.initialized) {
       this.events.trimSTNs(ERROR_MODE_SECONDS_WINDOW) // up until now, Trace would've been just buffering nodes up to max, which needs to be trimmed to last X seconds
+      this.agentRef.runtime.harvester.triggerHarvestFor(this)
     }
-    this.startHarvesting()
   }
 
   /** Stop running for the remainder of the page lifecycle */
@@ -194,7 +178,6 @@ export class Aggregate extends AggregateBase {
     this.blocked = true
     this.mode = MODE.OFF
     this.agentRef.runtime.session.write({ sessionTraceMode: this.mode })
-    this.scheduler?.stopTimer()
     this.events.clear()
   }
 }

package/src/features/session_trace/aggregate/trace/storage.js

@@ -273,7 +273,8 @@ export class TraceStorage {
     this.storeSTN(new TraceNode('Ajax', metrics.time, metrics.time + metrics.duration, `${params.status} ${params.method}: ${params.host}${params.pathname}`, 'ajax'))
   }
 
-  /* Below are the interface expected & required of whatever storage is used across all features on an individual basis. This allows a common `.events` property on Trace. */
+  /* Below are the interface expected & required of whatever storage is used across all features on an individual basis. This allows a common `.events` property on Trace shared with AggregateBase.
+    Note that the usage must be in sync with the EventStoreManager class such that AggregateBase.makeHarvestPayload can run the same regardless of which storage class a feature is using. */
   isEmpty () {
     return this.nodeCount === 0
   }
@@ -282,7 +283,9 @@ export class TraceStorage {
     this.#backupTrace = this.trace
   }
 
-  get = this.takeSTNs
+  get () {
+    return [{ targetApp: this.parent.agentRef.mainAppKey, data: this.takeSTNs() }]
+  }
 
   clear () {
     this.trace = {}

package/src/features/soft_navigations/aggregate/index.js

@@ -1,9 +1,8 @@
 import { handle } from '../../../common/event-emitter/handle'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { single } from '../../../common/util/invoke'
 import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte'
-import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { API_TRIGGER_NAME, FEATURE_NAME, INTERACTION_STATUS, INTERACTION_TRIGGERS, IPL_TRIGGER_NAME } from '../constants'
@@ -16,7 +15,6 @@ export class Aggregate extends AggregateBase {
   constructor (agentRef, { domObserver }) {
     super(agentRef, FEATURE_NAME)
 
-    const harvestTimeSeconds = agentRef.init.soft_navigations.harvestTimeSeconds || 10
     this.interactionsToHarvest = this.events
     this.domObserver = domObserver
 
@@ -36,18 +34,12 @@ export class Aggregate extends AggregateBase {
     this.latestRouteSetByApi = null
     this.interactionInProgress = null // aside from the "page load" interaction, there can only ever be 1 ongoing at a time
     this.latestHistoryUrl = null
+    this.harvestOpts.beforeUnload = () => this.interactionInProgress?.done() // return any withheld ajax or jserr events so they can be sent with EoL harvest
 
-    this.blocked = false
     this.waitForFlags(['spa']).then(([spaOn]) => {
       if (spaOn) {
         this.drain()
-        const scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-          onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
-          getPayload: (options) => this.makeHarvestPayload(options.retry),
-          retryDelay: harvestTimeSeconds,
-          onUnload: () => this.interactionInProgress?.done() // return any held ajax or jserr events so they can be sent with EoL harvest
-        }, this)
-        scheduler.startTimer(harvestTimeSeconds, 0)
+        setTimeout(() => agentRef.runtime.harvester.triggerHarvestFor(this), 0) // send the IPL ixn on next tick, giving some time for any ajax to finish; we may want to just remove this?
       } else {
         this.blocked = true // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
         this.deregisterDrain()
@@ -136,7 +128,7 @@ export class Aggregate extends AggregateBase {
     */
     if (this.interactionInProgress?.isActiveDuring(timestamp)) return this.interactionInProgress
     let saveIxn
-    const interactionsBuffer = this.interactionsToHarvest.get()
+    const interactionsBuffer = this.interactionsToHarvest.get(this.agentRef.mainAppKey)[0].data
     for (let idx = interactionsBuffer.length - 1; idx >= 0; idx--) { // reverse search for the latest completed interaction for efficiency
       const finishedInteraction = interactionsBuffer[idx]
       if (finishedInteraction.isActiveDuring(timestamp)) {

package/src/features/spa/aggregate/index.js

@@ -10,11 +10,10 @@ import { navTimingValues as navTiming } from '../../../common/timing/nav-timing'
 import { generateUuid } from '../../../common/ids/unique-id'
 import { Interaction } from './interaction'
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { Serializer } from './serializer'
 import { ee } from '../../../common/event-emitter/contextual-ee'
 import * as CONSTANTS from '../constants'
-import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint'
 import { firstPaint } from '../../../common/vitals/first-paint'
@@ -46,14 +45,12 @@ export class Aggregate extends AggregateBase {
       pageLoaded: false,
       childTime: 0,
       depth: 0,
-      harvestTimeSeconds: agentRef.init.spa.harvestTimeSeconds || 10,
       // The below feature flag is used to disable the SPA ajax fix for specific customers, see https://new-relic.atlassian.net/browse/NR-172169
       disableSpaFix: (agentRef.init.feature_flags || []).indexOf('disable-spa-fix') > -1
     }
     this.spaSerializerClass = new Serializer(this)
 
     const classThis = this
-    let scheduler
 
     const baseEE = ee.get(agentRef.agentIdentifier) // <-- parent baseEE
     const mutationEE = baseEE.get('mutation')
@@ -98,13 +95,10 @@ export class Aggregate extends AggregateBase {
     //  | click ending:                   |   65  |    50    |        |           |           |
     // click fn-end                       |   70  |    0     |    0   |     70    |     20    |
 
+    let harvester
     this.waitForFlags((['spa'])).then(([spaFlag]) => {
       if (spaFlag) {
-        scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-          onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
-          getPayload: (options) => this.makeHarvestPayload(options.retry),
-          retryDelay: state.harvestTimeSeconds
-        }, this)
+        harvester = agentRef.runtime.harvester // since this is after RUM call, PVE would've initialized harvester by now
         this.drain()
       } else {
         this.blocked = true
@@ -725,8 +719,11 @@ export class Aggregate extends AggregateBase {
       else smCategory = 'Custom'
       handle(SUPPORTABILITY_METRIC_CHANNEL, [`Spa/Interaction/${smCategory}/Duration/Ms`, Math.max((interaction.root?.end || 0) - (interaction.root?.start || 0), 0)], undefined, FEATURE_NAMES.metrics, baseEE)
 
-      scheduler?.scheduleHarvest(0)
-      if (!scheduler) warn(19)
+      if (!harvester) {
+        warn(19)
+        return
+      }
+      harvester.triggerHarvestFor(classThis)
     }
   }
 

package/src/features/utils/aggregate-base.js

@@ -5,19 +5,34 @@ import { gosCDN } from '../../common/window/nreum'
 import { drain } from '../../common/drain/drain'
 import { activatedFeatures } from '../../common/util/feature-flags'
 import { Obfuscator } from '../../common/util/obfuscate'
-import { EventBuffer } from './event-buffer'
 import { FEATURE_NAMES } from '../../loaders/features/features'
+import { EventStoreManager } from './event-store-manager'
+import { Harvester } from '../../common/harvest/harvester'
 
 export class AggregateBase extends FeatureBase {
   constructor (agentRef, featureName) {
     super(agentRef.agentIdentifier, featureName)
     this.agentRef = agentRef
-    // Jserror and Metric features uses a singleton EventAggregator instead of a regular EventBuffer.
-    if ([FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics].includes(this.featureName)) this.events = agentRef.sharedAggregator
-    // PVE has no need for eventBuffer, and SessionTrace has its own storage mechanism.
-    else if (![FEATURE_NAMES.pageViewEvent, FEATURE_NAMES.sessionTrace].includes(this.featureName)) this.events = new EventBuffer()
     this.checkConfiguration(agentRef)
-    this.obfuscator = agentRef.runtime.obfuscator
+    this.doOnceForAllAggregate(agentRef)
+
+    // This switch needs to be after doOnceForAllAggregate which may new sharedAggregator and reset mainAppKey.
+    switch (this.featureName) {
+      // PVE has no need for eventBuffer, and SessionTrace + Replay have their own storage mechanisms.
+      case FEATURE_NAMES.pageViewEvent:
+      case FEATURE_NAMES.sessionTrace:
+      case FEATURE_NAMES.sessionReplay:
+        break
+      // Jserror and Metric features uses a singleton EventAggregator instead of a regular EventBuffer.
+      case FEATURE_NAMES.jserrors:
+      case FEATURE_NAMES.metrics:
+        this.events = agentRef.sharedAggregator
+        break
+      default:
+        this.events = new EventStoreManager(agentRef.mainAppKey, 1)
+        break
+    }
+    this.harvestOpts = {} // features aggregate classes can define custom opts for when their harvest is called
   }
 
   /**
@@ -56,34 +71,40 @@ export class AggregateBase extends FeatureBase {
   /**
    * Return harvest payload. A "serializer" function can be defined on a derived class to format the payload.
    * @param {Boolean} shouldRetryOnFail - harvester flag to backup payload for retry later if harvest request fails; this should be moved to harvester logic
-   * @returns final payload, or undefined if there are no pending events
+   * @param {object|undefined} opts.target - the target app passed onto the event store manager to determine which app's data to return; if none provided, all apps data will be returned
+   * @returns {Array} Final payload tagged with their targeting browser app. The value of `payload` can be undefined if there are no pending events for an app. This should be a minimum length of 1.
    */
   makeHarvestPayload (shouldRetryOnFail = false, opts = {}) {
-    if (this.events.isEmpty(opts)) return
+    if (this.events.isEmpty(this.harvestOpts, opts.target)) return
     // Other conditions and things to do when preparing harvest that is required.
-    if (this.preHarvestChecks && !this.preHarvestChecks()) return
+    if (this.preHarvestChecks && !this.preHarvestChecks(opts)) return
 
-    if (shouldRetryOnFail) this.events.save(opts)
-    const returnedData = this.events.get(opts)
-    // A serializer or formatter assists in creating the payload `body` from stored events on harvest when defined by derived feature class.
-    const body = this.serializer ? this.serializer(returnedData) : returnedData
-    this.events.clear(opts)
+    if (shouldRetryOnFail) this.events.save(this.harvestOpts, opts.target)
+    const returnedDataArr = this.events.get(this.harvestOpts, opts.target)
+    if (!returnedDataArr.length) throw new Error('Unexpected problem encountered. There should be at least one app for harvest!')
+    this.events.clear(this.harvestOpts, opts.target)
 
-    const payload = {
-      body
-    }
-    // Constructs the payload `qs` for relevant features on harvest.
-    if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(returnedData)
-    return payload
+    return returnedDataArr.map(({ targetApp, data }) => {
+      // A serializer or formatter assists in creating the payload `body` from stored events on harvest when defined by derived feature class.
+      const body = this.serializer ? this.serializer(data) : data
+      const payload = {
+        body
+      }
+      // Constructs the payload `qs` for relevant features on harvest.
+      if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(data)
+
+      return { targetApp, payload }
+    })
   }
 
   /**
    * Cleanup task after a harvest.
-   * @param {Boolean} harvestFailed - harvester flag to restore events in main buffer for retry later if request failed
+   * @param {object} result - the cbResult object from the harvester's send method
    */
-  postHarvestCleanup (harvestFailed = false, opts = {}) {
-    if (harvestFailed) this.events.reloadSave(opts)
-    this.events.clearSave(opts)
+  postHarvestCleanup (result = {}) {
+    const harvestFailed = result.sent && result.retry
+    if (harvestFailed) this.events.reloadSave(this.harvestOpts, result.targetApp)
+    this.events.clearSave(this.harvestOpts, result.targetApp)
   }
 
   /**
@@ -112,9 +133,20 @@ export class AggregateBase extends FeatureBase {
         runtime: existingAgent.runtime
       })
     }
+  }
 
-    if (!existingAgent.runtime.obfuscator) {
-      existingAgent.runtime.obfuscator = new Obfuscator(this.agentIdentifier)
-    }
+  /**
+   * These are actions related to shared resources that should be initialized once by whichever feature Aggregate subclass loads first.
+   * This method should run after checkConfiguration, which may reset the agent's info/runtime object that is used here.
+   */
+  doOnceForAllAggregate (agentRef) {
+    if (!agentRef.runtime.obfuscator) agentRef.runtime.obfuscator = new Obfuscator(this.agentIdentifier)
+    this.obfuscator = agentRef.runtime.obfuscator
+
+    if (!agentRef.mainAppKey) agentRef.mainAppKey = { licenseKey: agentRef.info.licenseKey, appId: agentRef.info.applicationID }
+    // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
+    if (!agentRef.sharedAggregator) agentRef.sharedAggregator = new EventStoreManager(agentRef.mainAppKey, 2)
+
+    if (!agentRef.runtime.harvester) agentRef.runtime.harvester = new Harvester(agentRef)
   }
 }

package/src/features/utils/event-buffer.js

@@ -53,7 +53,6 @@ export class EventBuffer {
 
   /**
    * Backup the buffered data and clear the main buffer
-   * @returns {Array} the events being backed up
    */
   save () {
     this.#bufferBackup = this.#buffer

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

@@ -0,0 +1,101 @@
+import { EventAggregator } from '../../common/aggregate/event-aggregator'
+import { EventBuffer } from './event-buffer'
+
+/**
+ * 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.
+ */
+export class EventStoreManager {
+  /**
+   * @param {object} defaultTarget - should contain licenseKey and appId of the main app from NREUM.info at startup
+   * @param {1|2} storageChoice - the type of storage to use in this manager; 'EventBuffer' (1), 'EventAggregator' (2)
+   */
+  constructor (defaultTarget, storageChoice) {
+    this.mainApp = defaultTarget
+    this.StorageClass = storageChoice === 1 ? EventBuffer : EventAggregator
+    this.appStorageMap = new Map()
+    this.appStorageMap.set(defaultTarget, new this.StorageClass())
+  }
+
+  // This class must contain an union of all methods from all supported storage classes and conceptualize away the target app argument.
+
+  /**
+   * @param {object} optsIfPresent - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
+   * @param {object} target - specific app's storage to check; if not provided, this method takes into account all apps recorded by this manager
+   * @returns {boolean} True if the target's storage is empty, or target does not exist in map (defaults to all storages)
+   */
+  isEmpty (optsIfPresent, target) {
+    if (target) {
+      if (!this.appStorageMap.has(target)) return true
+      else return this.appStorageMap.get(target).isEmpty(optsIfPresent)
+    }
+    for (const eventStore of this.appStorageMap.values()) {
+      if (!eventStore.isEmpty(optsIfPresent)) return false
+    }
+    return true
+  }
+
+  /**
+   * @param {string} event - the event element to store
+   * @param {object} target - the app to store event under; if not provided, this method adds to the main app from NREUM.info
+   * @returns {boolean} True if the event was successfully added
+   */
+  add (event, target) {
+    if (target && !this.appStorageMap.has(target)) this.appStorageMap.set(target, new this.StorageClass())
+    return this.appStorageMap.get(target || this.mainApp).add(event)
+  }
+
+  /** This is only used by the Metrics feature which has no need to add metric under a different app atm. */
+  addMetric (type, name, params, value) {
+    return this.appStorageMap.get(this.mainApp).addMetric(type, name, params, value)
+  }
+
+  /**
+   * @param {object} optsIfPresent - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
+   * @param {object} target - specific app to fetch; if not provided, this method fetches from all apps
+   * @returns {Array} Objects of `data` labeled with their respective `target` app to be sent to
+   */
+  get (optsIfPresent, target) {
+    if (target) return [{ targetApp: target, data: this.appStorageMap.get(target)?.get(optsIfPresent) }]
+    const allPayloads = []
+    this.appStorageMap.forEach((eventStore, recordedTarget) => {
+      allPayloads.push({ targetApp: recordedTarget, data: eventStore.get(optsIfPresent) })
+    })
+    return allPayloads
+  }
+
+  byteSize (target) {
+    return this.appStorageMap.get(target || this.mainApp).byteSize()
+  }
+
+  wouldExceedMaxSize (incomingSize, target) {
+    return this.appStorageMap.get(target || this.mainApp).wouldExceedMaxSize(incomingSize)
+  }
+
+  save (optsIfPresent, target) {
+    if (target) return this.appStorageMap.get(target)?.save(optsIfPresent)
+    this.appStorageMap.forEach((eventStore) => eventStore.save(optsIfPresent))
+  }
+
+  clear (optsIfPresent, target) {
+    if (target) return this.appStorageMap.get(target)?.clear(optsIfPresent)
+    this.appStorageMap.forEach((eventStore) => eventStore.clear(optsIfPresent))
+  }
+
+  // Unlike the methods above, the following will have a target as they are called by AggregateBase.postHarvestCleanup callback on harvest finish after getting & sending the data.
+  reloadSave (optsIfPresent, target) {
+    if (!target) { // -- remove this block once the old harvest.js & harvest-schedule.js are deleted!
+      this.appStorageMap.forEach((eventStore) => eventStore.reloadSave(optsIfPresent))
+      return
+    }
+    return this.appStorageMap.get(target)?.reloadSave(optsIfPresent)
+  }
+
+  clearSave (optsIfPresent, target) {
+    if (!target) { // -- remove this block once the old harvest.js & harvest-schedule.js are deleted!
+      this.appStorageMap.forEach((eventStore) => eventStore.clearSave(optsIfPresent))
+      return
+    }
+    return this.appStorageMap.get(target)?.clearSave(optsIfPresent)
+  }
+}

package/src/features/utils/instrument-base.js

@@ -43,7 +43,6 @@ export class InstrumentBase extends FeatureBase {
     /**
      * @type {Promise} Assigned immediately after @see importAggregator runs. Serves as a signal for when the inner async fn finishes execution. Useful for features to await
      * one another if there are inter-features dependencies.
-     * TODO: This is only used for the SPA feature component tests and should be refactored out.
     */
     this.onAggregateImported = undefined
 
@@ -95,13 +94,6 @@ export class InstrumentBase extends FeatureBase {
        * it's only responsible for aborting its one specific feature, rather than all.
        */
       try {
-        // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
-        if (!agentRef.sharedAggregator) {
-          agentRef.sharedAggregator = import(/* webpackChunkName: "shared-aggregator" */ '../../common/aggregate/event-aggregator')
-          const { EventAggregator } = await agentRef.sharedAggregator
-          agentRef.sharedAggregator = new EventAggregator()
-        } else await agentRef.sharedAggregator // if another feature is already importing the aggregator, wait for it to finish
-
         if (!this.#shouldImportAgg(this.featureName, session)) {
           drain(this.agentIdentifier, this.featureName)
           loadedSuccessfully(false) // aggregate module isn't loaded at all
@@ -110,6 +102,8 @@ export class InstrumentBase extends FeatureBase {
         const { lazyFeatureLoader } = await import(/* webpackChunkName: "lazy-feature-loader" */ './lazy-feature-loader')
         const { Aggregate } = await lazyFeatureLoader(this.featureName, 'aggregate')
         this.featAggregate = new Aggregate(agentRef, argsObjFromInstrument)
+
+        agentRef.runtime.harvester.initializedAggregates.push(this.featAggregate) // "subscribe" the feature to future harvest intervals (PVE will start the timer)
         loadedSuccessfully(true)
       } catch (e) {
         warn(34, e)

package/src/loaders/features/features.js

@@ -1,7 +1,13 @@
+// To reduce build size a bit:
+export const EVENTS = 'events'
+export const JSERRORS = 'jserrors'
+const BLOBS = 'browser/blobs'
+export const RUM = 'rum'
+
 export const FEATURE_NAMES = {
   ajax: 'ajax',
   genericEvents: 'generic_events',
-  jserrors: 'jserrors',
+  jserrors: JSERRORS,
   logging: 'logging',
   metrics: 'metrics',
   /**
@@ -35,14 +41,15 @@ export const featurePriority = {
 }
 
 export const FEATURE_TO_ENDPOINT = {
-  [FEATURE_NAMES.pageViewTiming]: 'events',
-  [FEATURE_NAMES.ajax]: 'events',
-  [FEATURE_NAMES.spa]: 'events',
-  [FEATURE_NAMES.softNav]: 'events',
-  [FEATURE_NAMES.metrics]: 'jserrors',
-  [FEATURE_NAMES.jserrors]: 'jserrors',
-  [FEATURE_NAMES.sessionTrace]: 'browser/blobs',
-  [FEATURE_NAMES.sessionReplay]: 'browser/blobs',
+  [FEATURE_NAMES.pageViewEvent]: RUM,
+  [FEATURE_NAMES.pageViewTiming]: EVENTS,
+  [FEATURE_NAMES.ajax]: EVENTS,
+  [FEATURE_NAMES.spa]: EVENTS,
+  [FEATURE_NAMES.softNav]: EVENTS,
+  [FEATURE_NAMES.metrics]: JSERRORS,
+  [FEATURE_NAMES.jserrors]: JSERRORS,
+  [FEATURE_NAMES.sessionTrace]: BLOBS,
+  [FEATURE_NAMES.sessionReplay]: BLOBS,
   [FEATURE_NAMES.logging]: 'browser/logs',
   [FEATURE_NAMES.genericEvents]: 'ins'
 }

package/src/loaders/micro-agent.js

@@ -64,6 +64,7 @@ export class MicroAgent extends MicroAgentBase {
                 return lazyFeatureLoader(f, 'aggregate')
               }).then(({ Aggregate }) => {
                 this.features[f] = new Aggregate(this)
+                this.runtime.harvester.initializedAggregates.push(this.features[f]) // so that harvester will poll this feature agg on interval
               }).catch(err => warn(25, err))
             }
           })