@newrelic/browser-agent 1.272.0 → 1.273.0

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

@@ -7,6 +7,7 @@ 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 +19,6 @@ export class Aggregate extends AggregateBase {
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
 
-    /** A buffer to hold on to harvested traces in the case that a retry must be made later */
-    this.sentTrace = null
     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
@@ -28,7 +27,7 @@ export class Aggregate extends AggregateBase {
     /** If the harvest module is harvesting */
     this.harvesting = false
     /** TraceStorage is the mechanism that holds, normalizes and aggregates ST nodes.  It will be accessed and purged when harvests occur */
-    this.traceStorage = new TraceStorage(this)
+    this.events = new TraceStorage(this)
     /** 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))
@@ -60,9 +59,9 @@ export class Aggregate extends AggregateBase {
       })
 
       if (typeof PerformanceNavigationTiming !== 'undefined') {
-        this.traceStorage.storeTiming(globalScope.performance?.getEntriesByType?.('navigation')[0])
+        this.events.storeTiming(globalScope.performance?.getEntriesByType?.('navigation')[0])
       } else {
-        this.traceStorage.storeTiming(globalScope.performance?.timing, true)
+        this.events.storeTiming(globalScope.performance?.timing, true)
       }
     }
 
@@ -77,21 +76,21 @@ export class Aggregate extends AggregateBase {
 
     this.timeKeeper ??= this.agentRef.runtime.timeKeeper
 
-    this.scheduler = new HarvestScheduler('browser/blobs', {
-      onFinished: this.onHarvestFinished.bind(this),
+    this.scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
+      onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
       retryDelay: this.harvestTimeSeconds,
-      getPayload: this.prepareHarvest.bind(this),
+      getPayload: (options) => this.makeHarvestPayload(options.retry),
       raw: true
     }, this)
 
     /** The handlers set up by the Inst file */
-    registerHandler('bst', (...args) => this.traceStorage.storeEvent(...args), this.featureName, this.ee)
-    registerHandler('bstResource', (...args) => this.traceStorage.storeResources(...args), this.featureName, this.ee)
-    registerHandler('bstHist', (...args) => this.traceStorage.storeHist(...args), this.featureName, this.ee)
-    registerHandler('bstXhrAgg', (...args) => this.traceStorage.storeXhrAgg(...args), this.featureName, this.ee)
-    registerHandler('bstApi', (...args) => this.traceStorage.storeSTN(...args), this.featureName, this.ee)
-    registerHandler('trace-jserror', (...args) => this.traceStorage.storeErrorAgg(...args), this.featureName, this.ee)
-    registerHandler('pvtAdded', (...args) => this.traceStorage.processPVT(...args), this.featureName, this.ee)
+    registerHandler('bst', (...args) => this.events.storeEvent(...args), this.featureName, this.ee)
+    registerHandler('bstResource', (...args) => this.events.storeResources(...args), this.featureName, this.ee)
+    registerHandler('bstHist', (...args) => this.events.storeHist(...args), this.featureName, this.ee)
+    registerHandler('bstXhrAgg', (...args) => this.events.storeXhrAgg(...args), this.featureName, this.ee)
+    registerHandler('bstApi', (...args) => this.events.storeSTN(...args), this.featureName, this.ee)
+    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()
@@ -112,28 +111,32 @@ export class Aggregate extends AggregateBase {
     this.scheduler.startTimer(this.harvestTimeSeconds)
   }
 
-  /** Called by the harvest scheduler at harvest time to retrieve the payload.  This will only actually return a payload if running in full mode */
-  prepareHarvest (options = {}) {
-    this.traceStorage.prevStoredEvents.clear() // release references to past events for GC
+  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
-    if (this.blocked || this.mode !== MODE.FULL || this.traceStorage.nodeCount === 0) return
-    if (this.sessionId !== this.agentRef.runtime.session?.state.value || this.ptid !== this.agentRef.runtime.ptid) return this.abort(3) // if something unexpected happened and we somehow still got to the point of harvesting after a session identifier changed, we should force-exit instead of harvesting
-    /** Get the ST nodes from the traceStorage buffer.  This also returns helpful metadata about the payload. */
-    const { stns, earliestTimeStamp, latestTimeStamp } = this.traceStorage.takeSTNs()
-    if (!stns) return // there are no trace nodes
-    if (options.retry) {
-      this.sentTrace = stns
+    if (!this.agentRef.runtime.session) return // session entity is required for trace to run and continue running
+    if (this.sessionId !== this.agentRef.runtime.session.state.value || this.ptid !== this.agentRef.runtime.ptid) {
+      // If something unexpected happened and we somehow still got to harvesting after a session identifier changed, we should force-exit instead of harvesting:
+      this.abort(3)
+      return
     }
+    return true
+  }
+
+  serializer ({ stns }) {
+    if (!stns.length) return // there are no processed nodes
+    this.everHarvested = true
+    return applyFnToProps(stns, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
+  }
 
+  queryStringsBuilder ({ stns, earliestTimeStamp, latestTimeStamp }) {
     const firstSessionHarvest = !this.agentRef.runtime.session.state.traceHarvestStarted
     if (firstSessionHarvest) this.agentRef.runtime.session.write({ traceHarvestStarted: true })
+    const hasReplay = this.agentRef.runtime.session.state.sessionReplayMode === 1
+    const endUserId = this.agentRef.info.jsAttributes['enduser.id']
+    const entityGuid = this.agentRef.runtime.appMetadata.agents?.[0]?.entityGuid
 
-    const hasReplay = this.agentRef.runtime.session?.state.sessionReplayMode === 1
-    const endUserId = this.agentRef.info?.jsAttributes?.['enduser.id']
-
-    this.everHarvested = true
-
-    /** The blob consumer expects the following and will reject if not supplied:
+    /* The blob consumer expects the following and will reject if not supplied:
      * browser_monitoring_key
      * type
      * app_id
@@ -142,47 +145,34 @@ export class Aggregate extends AggregateBase {
      *
      * For data that does not fit the schema of the above, it should be url-encoded and placed into `attributes`
      */
-    const agentMetadata = this.agentRef.runtime.appMetadata?.agents?.[0] || {}
-    return {
-      qs: {
-        browser_monitoring_key: this.agentRef.info.licenseKey,
-        type: 'BrowserSessionChunk',
-        app_id: this.agentRef.info.applicationID,
-        protocol_version: '0',
-        timestamp: Math.floor(this.timeKeeper.correctRelativeTimestamp(earliestTimeStamp)),
-        attributes: encodeObj({
-          ...(agentMetadata.entityGuid && { entityGuid: agentMetadata.entityGuid }),
-          harvestId: `${this.agentRef.runtime.session?.state.value}_${this.agentRef.runtime.ptid}_${this.agentRef.runtime.harvestCount}`,
-          // this section of attributes must be controllable and stay below the query param padding limit -- see QUERY_PARAM_PADDING
-          // if not, data could be lost to truncation at time of sending, potentially breaking parsing / API behavior in NR1
-          // trace payload metadata
-          'trace.firstTimestamp': Math.floor(this.timeKeeper.correctRelativeTimestamp(earliestTimeStamp)),
-          'trace.lastTimestamp': Math.floor(this.timeKeeper.correctRelativeTimestamp(latestTimeStamp)),
-          'trace.nodes': stns.length,
-          'trace.originTimestamp': this.timeKeeper.correctedOriginTime,
-          // other payload metadata
-          agentVersion: this.agentRef.runtime.version,
-          ...(firstSessionHarvest && { firstSessionHarvest }),
-          ...(hasReplay && { hasReplay }),
-          ptid: `${this.ptid}`,
-          session: `${this.sessionId}`,
-          // customer-defined data should go last so that if it exceeds the query param padding limit it will be truncated instead of important attrs
-          ...(endUserId && { 'enduser.id': this.obfuscator.obfuscateString(endUserId) }),
-          currentUrl: this.obfuscator.obfuscateString(cleanURL('' + location))
-          // The Query Param is being arbitrarily limited in length here.  It is also applied when estimating the size of the payload in getPayloadSize()
-        }, QUERY_PARAM_PADDING).substring(1) // remove the leading '&'
-      },
-      body: applyFnToProps(stns, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
-    }
-  }
 
-  /** When the harvest scheduler finishes, this callback is executed. It's main purpose is to determine if the payload needs to be retried
-   * and if so, it will take all data from the temporary buffer and place it back into the traceStorage module
-   */
-  onHarvestFinished (result) {
-    if (result.sent && result.retry && this.sentTrace) { // merge previous trace back into buffer to retry for next harvest
-      Object.entries(this.sentTrace).forEach(([name, listOfSTNodes]) => { this.traceStorage.restoreNode(name, listOfSTNodes) })
-      this.sentTrace = null
+    return {
+      browser_monitoring_key: this.agentRef.info.licenseKey,
+      type: 'BrowserSessionChunk',
+      app_id: this.agentRef.info.applicationID,
+      protocol_version: '0',
+      timestamp: Math.floor(this.timeKeeper.correctRelativeTimestamp(earliestTimeStamp)),
+      attributes: encodeObj({
+        ...(entityGuid && { entityGuid }),
+        harvestId: `${this.agentRef.runtime.session.state.value}_${this.agentRef.runtime.ptid}_${this.agentRef.runtime.harvestCount}`,
+        // this section of attributes must be controllable and stay below the query param padding limit -- see QUERY_PARAM_PADDING
+        // if not, data could be lost to truncation at time of sending, potentially breaking parsing / API behavior in NR1
+        // trace payload metadata
+        'trace.firstTimestamp': Math.floor(this.timeKeeper.correctRelativeTimestamp(earliestTimeStamp)),
+        'trace.lastTimestamp': Math.floor(this.timeKeeper.correctRelativeTimestamp(latestTimeStamp)),
+        'trace.nodes': stns.length,
+        'trace.originTimestamp': this.timeKeeper.correctedOriginTime,
+        // other payload metadata
+        agentVersion: this.agentRef.runtime.version,
+        ...(firstSessionHarvest && { firstSessionHarvest }),
+        ...(hasReplay && { hasReplay }),
+        ptid: `${this.ptid}`,
+        session: `${this.sessionId}`,
+        // customer-defined data should go last so that if it exceeds the query param padding limit it will be truncated instead of important attrs
+        ...(endUserId && { 'enduser.id': this.obfuscator.obfuscateString(endUserId) }),
+        currentUrl: this.obfuscator.obfuscateString(cleanURL('' + location))
+        // The Query Param is being arbitrarily limited in length here.  It is also applied when estimating the size of the payload in getPayloadSize()
+      }, QUERY_PARAM_PADDING).substring(1) // remove the leading '&'
     }
   }
 
@@ -194,16 +184,17 @@ export class Aggregate extends AggregateBase {
     this.agentRef.runtime.session.write({ sessionTraceMode: this.mode })
     if (prevMode === MODE.OFF || !this.initialized) return this.initialize(this.mode, this.entitled)
     if (this.initialized) {
-      this.traceStorage.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.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.startHarvesting()
   }
 
   /** Stop running for the remainder of the page lifecycle */
-  abort (reason) {
+  abort () {
     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

@@ -29,8 +29,8 @@ export class TraceStorage {
   trace = {}
   earliestTimeStamp = Infinity
   latestTimeStamp = 0
-  tempStorage = []
   prevStoredEvents = new Set()
+  #backupTrace
 
   constructor (parent) {
     this.parent = parent
@@ -44,9 +44,6 @@ export class TraceStorage {
       const openedSpace = this.trimSTNs(ERROR_MODE_SECONDS_WINDOW) // but maybe we could make some space by discarding irrelevant nodes if we're in sessioned Error mode
       if (openedSpace === 0) return
     }
-    while (this.tempStorage.length) {
-      this.storeSTN(this.tempStorage.shift())
-    }
 
     if (this.trace[stn.n]) this.trace[stn.n].push(stn)
     else this.trace[stn.n] = [stn]
@@ -96,15 +93,9 @@ export class TraceStorage {
       const partitionListByOriginMap = listOfSTNodes.sort((a, b) => a.s - b.s).reduce(reindexByOriginFn, {})
       return Object.values(partitionListByOriginMap).flat() // join the partitions back into 1-D, now ordered by origin then start time
     }, this)
-    if (stns.length === 0) return {}
 
-    this.trace = {}
-    this.nodeCount = 0
     const earliestTimeStamp = this.earliestTimeStamp
-    this.earliestTimeStamp = Infinity
     const latestTimeStamp = this.latestTimeStamp
-    this.latestTimeStamp = 0
-
     return { stns, earliestTimeStamp, latestTimeStamp }
   }
 
@@ -282,10 +273,30 @@ export class TraceStorage {
     this.storeSTN(new TraceNode('Ajax', metrics.time, metrics.time + metrics.duration, `${params.status} ${params.method}: ${params.host}${params.pathname}`, 'ajax'))
   }
 
-  restoreNode (name, listOfSTNodes) {
-    if (this.nodeCount >= MAX_NODES_PER_HARVEST) return
+  /* 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. */
+  isEmpty () {
+    return this.nodeCount === 0
+  }
+
+  save () {
+    this.#backupTrace = this.trace
+  }
+
+  get = this.takeSTNs
+
+  clear () {
+    this.trace = {}
+    this.nodeCount = 0
+    this.prevStoredEvents.clear() // release references to past events for GC
+    this.earliestTimeStamp = Infinity
+    this.latestTimeStamp = 0
+  }
+
+  reloadSave () {
+    Object.values(this.#backupTrace).forEach(stnsArray => stnsArray.forEach(stn => this.storeSTN(stn)))
+  }
 
-    this.nodeCount += listOfSTNodes.length
-    this.trace[name] = this.trace[name] ? listOfSTNodes.concat(this.trace[name]) : listOfSTNodes
+  clearSave () {
+    this.#backupTrace = undefined
   }
 }

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

@@ -3,10 +3,9 @@ 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 } from '../../../loaders/features/features'
+import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { AggregateBase } from '../../utils/aggregate-base'
-import { EventBuffer } from '../../utils/event-buffer'
 import { API_TRIGGER_NAME, FEATURE_NAME, INTERACTION_STATUS } from '../constants'
 import { AjaxNode } from './ajax-node'
 import { InitialPageLoadInteraction } from './initial-page-load-interaction'
@@ -18,7 +17,7 @@ export class Aggregate extends AggregateBase {
     super(agentRef, FEATURE_NAME)
 
     const harvestTimeSeconds = agentRef.init.soft_navigations.harvestTimeSeconds || 10
-    this.interactionsToHarvest = new EventBuffer()
+    this.interactionsToHarvest = this.events
     this.domObserver = domObserver
 
     this.initialPageLoadInteraction = new InitialPageLoadInteraction(agentRef.agentIdentifier)
@@ -39,12 +38,12 @@ export class Aggregate extends AggregateBase {
     this.waitForFlags(['spa']).then(([spaOn]) => {
       if (spaOn) {
         this.drain()
-        const scheduler = new HarvestScheduler('events', {
-          onFinished: this.onHarvestFinished.bind(this),
+        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.harvest.on('events', this.onHarvestStarted.bind(this))
         scheduler.startTimer(harvestTimeSeconds, 0)
       } else {
         this.blocked = true // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
@@ -66,27 +65,16 @@ export class Aggregate extends AggregateBase {
     registerHandler('jserror', this.#handleJserror.bind(this), this.featureName, this.ee)
   }
 
-  onHarvestStarted (options) {
-    if (!this.interactionsToHarvest.hasData || this.blocked) return
+  serializer (eventBuffer) {
     // The payload depacker takes the first ixn of a payload (if there are multiple ixns) and positively offset the subsequent ixns timestamps by that amount.
     // In order to accurately portray the real start & end times of the 2nd & onward ixns, we hence need to negatively offset their start timestamps with that of the 1st ixn.
     let firstIxnStartTime = 0 // the very 1st ixn does not require any offsetting
     const serializedIxnList = []
-    for (const interaction of this.interactionsToHarvest.buffer) {
+    for (const interaction of eventBuffer) {
       serializedIxnList.push(interaction.serialize(firstIxnStartTime))
       if (!firstIxnStartTime) firstIxnStartTime = Math.floor(interaction.start)
     }
-    const payload = `bel.7;${serializedIxnList.join(';')}`
-
-    if (options.retry) this.interactionsToHarvest.hold()
-    else this.interactionsToHarvest.clear()
-
-    return { body: { e: payload } }
-  }
-
-  onHarvestFinished (result) {
-    if (result.sent && result.retry && this.interactionsToHarvest.held.hasData) this.interactionsToHarvest.unhold()
-    else this.interactionsToHarvest.held.clear()
+    return `bel.7;${serializedIxnList.join(';')}`
   }
 
   startUIInteraction (eventName, startedAt, sourceElem) { // this is throttled by instrumentation so that it isn't excessively called
@@ -139,8 +127,9 @@ export class Aggregate extends AggregateBase {
     */
     if (this.interactionInProgress?.isActiveDuring(timestamp)) return this.interactionInProgress
     let saveIxn
-    for (let idx = this.interactionsToHarvest.buffer.length - 1; idx >= 0; idx--) { // reverse search for the latest completed interaction for efficiency
-      const finishedInteraction = this.interactionsToHarvest.buffer[idx]
+    const interactionsBuffer = this.interactionsToHarvest.get()
+    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)) {
         if (finishedInteraction.trigger !== 'initialPageLoad') return finishedInteraction
         // It's possible that a complete interaction occurs before page is fully loaded, so we need to consider if a route-change ixn may have overlapped this iPL

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

@@ -3,7 +3,6 @@ import { isBrowserScope } from '../../../common/constants/runtime'
 import { handle } from '../../../common/event-emitter/handle'
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
 import { debounce } from '../../../common/util/invoke'
-import { wrapEvents } from '../../../common/wrap/wrap-events'
 import { wrapHistory } from '../../../common/wrap/wrap-history'
 import { InstrumentBase } from '../../utils/instrument-base'
 import { FEATURE_NAME, INTERACTION_TRIGGERS } from '../constants'
@@ -23,7 +22,12 @@ export class Instrument extends InstrumentBase {
     if (!isBrowserScope || !gosNREUMOriginals().o.MO) return // soft navigations is not supported outside web env or browsers without the mutation observer API
 
     const historyEE = wrapHistory(this.ee)
-    const eventsEE = wrapEvents(this.ee)
+
+    INTERACTION_TRIGGERS.forEach((trigger) => {
+      windowAddEventListener(trigger, (evt) => {
+        processUserInteraction(evt)
+      }, true)
+    })
 
     const trackURLChange = () => handle('newURL', [now(), '' + window.location], undefined, this.featureName, this.ee)
     historyEE.on('pushState-end', trackURLChange)
@@ -50,13 +54,6 @@ export class Instrument extends InstrumentBase {
       domObserver.observe(document.body, { attributes: true, childList: true, subtree: true, characterData: true })
     }, UI_WAIT_INTERVAL, { leading: true })
 
-    eventsEE.on('fn-start', ([evt]) => { // set up a new user ixn before the callback for the triggering event executes
-      if (INTERACTION_TRIGGERS.includes(evt?.type)) {
-        processUserInteraction(evt)
-      }
-    })
-    for (let eventType of INTERACTION_TRIGGERS) document.addEventListener(eventType, () => { /* no-op, this ensures the UI events are monitored by our callback above */ })
-
     this.abortHandler = abort
     this.importAggregator(agentRef, { domObserver })
 

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

@@ -14,7 +14,7 @@ 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 } from '../../../loaders/features/features'
+import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } 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'
@@ -23,7 +23,6 @@ import { initialLocation, loadedAsDeferredBrowserScript } from '../../../common/
 import { handle } from '../../../common/event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { warn } from '../../../common/util/console'
-import { EventBuffer } from '../../utils/event-buffer'
 
 const {
   FEATURE_NAME, INTERACTION_EVENTS, MAX_TIMER_BUDGET, FN_START, FN_END, CB_START, INTERACTION_API, REMAINING,
@@ -34,7 +33,7 @@ export class Aggregate extends AggregateBase {
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
 
-    this.state = {
+    const state = this.state = {
       initialPageURL: initialLocation,
       lastSeenUrl: initialLocation,
       lastSeenRouteName: null,
@@ -48,15 +47,13 @@ export class Aggregate extends AggregateBase {
       childTime: 0,
       depth: 0,
       harvestTimeSeconds: agentRef.init.spa.harvestTimeSeconds || 10,
-      interactionsToHarvest: new EventBuffer(),
       // 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
-    this.serializer = new Serializer(this)
-
-    const { state, serializer } = this
 
     const baseEE = ee.get(agentRef.agentIdentifier) // <-- parent baseEE
     const mutationEE = baseEE.get('mutation')
@@ -103,11 +100,11 @@ export class Aggregate extends AggregateBase {
 
     this.waitForFlags((['spa'])).then(([spaFlag]) => {
       if (spaFlag) {
-        scheduler = new HarvestScheduler('events', {
-          onFinished: onHarvestFinished,
+        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)
-        scheduler.harvest.on('events', onHarvestStarted)
         this.drain()
       } else {
         this.blocked = true
@@ -670,22 +667,6 @@ export class Aggregate extends AggregateBase {
       setCurrentNode(null)
     }
 
-    const classThis = this
-    function onHarvestStarted (options) {
-      if (!state.interactionsToHarvest.hasData || classThis.blocked) return {}
-      var payload = serializer.serializeMultiple(state.interactionsToHarvest.buffer, 0, navTiming)
-
-      if (options.retry) state.interactionsToHarvest.hold()
-      else state.interactionsToHarvest.clear()
-
-      return { body: { e: payload } }
-    }
-
-    function onHarvestFinished (result) {
-      if (result.sent && result.retry && state.interactionsToHarvest.held.hasData) state.interactionsToHarvest.unhold()
-      else state.interactionsToHarvest.held.clear()
-    }
-
     baseEE.on('spa-jserror', function (type, name, params, metrics) {
       if (!state.currentNode) return
       params._interactionId = state.currentNode.interaction.id
@@ -736,7 +717,7 @@ export class Aggregate extends AggregateBase {
         interaction.root.attrs.firstContentfulPaint = firstContentfulPaint.current.value
       }
       baseEE.emit('interactionDone', [interaction, true])
-      state.interactionsToHarvest.add(interaction)
+      classThis.events.add(interaction)
 
       let smCategory
       if (interaction.root?.attrs?.trigger === 'initialPageLoad') smCategory = 'InitialPageLoad'
@@ -748,4 +729,8 @@ export class Aggregate extends AggregateBase {
       if (!scheduler) warn(19)
     }
   }
+
+  serializer (eventBuffer) {
+    return this.spaSerializerClass.serializeMultiple(eventBuffer, 0, navTiming)
+  }
 }

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

@@ -5,11 +5,17 @@ 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'
 
 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
   }
@@ -47,6 +53,39 @@ export class AggregateBase extends FeatureBase {
     this.drained = true
   }
 
+  /**
+   * 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
+   */
+  makeHarvestPayload (shouldRetryOnFail = false, opts = {}) {
+    if (this.events.isEmpty(opts)) return
+    // Other conditions and things to do when preparing harvest that is required.
+    if (this.preHarvestChecks && !this.preHarvestChecks()) 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)
+
+    const payload = {
+      body
+    }
+    // Constructs the payload `qs` for relevant features on harvest.
+    if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(returnedData)
+    return payload
+  }
+
+  /**
+   * Cleanup task after a harvest.
+   * @param {Boolean} harvestFailed - harvester flag to restore events in main buffer for retry later if request failed
+   */
+  postHarvestCleanup (harvestFailed = false, opts = {}) {
+    if (harvestFailed) this.events.reloadSave(opts)
+    this.events.clearSave(opts)
+  }
+
   /**
    * Checks for additional `jsAttributes` items to support backward compatibility with implementations of the agent where
    * loader configurations may appear after the loader code is executed.