@newrelic/browser-agent 1.271.0 → 1.273.0

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

@@ -7,6 +7,7 @@ import { onDOMContentLoaded } from '../../../common/window/load'
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
 import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime'
 import { AggregateBase } from '../../utils/aggregate-base'
+import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { isIFrameWindow } from '../../../common/dom/iframe'
 // import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
 // import { handleWebsocketEvents } from './websocket-detection'
@@ -15,13 +16,14 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
+    const aggregatorTypes = ['cm', 'sm'] // the types in EventAggregator this feature cares about
 
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
         // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
-        const scheduler = new HarvestScheduler('jserrors', { onUnload: () => this.unload() }, this)
+        const scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], { onUnload: () => this.unload() }, this)
         // this is needed to ensure EoL is "on" and sent
-        scheduler.harvest.on('jserrors', () => ({ body: this.agentRef.sharedAggregator.take(['cm', 'sm']) }))
+        scheduler.harvest.on(FEATURE_TO_ENDPOINT[this.featureName], () => this.makeHarvestPayload(undefined, { aggregatorTypes }))
         this.drain()
       } else {
         this.blocked = true // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
@@ -41,14 +43,14 @@ export class Aggregate extends AggregateBase {
     if (this.blocked) return
     const type = SUPPORTABILITY_METRIC
     const params = { name }
-    this.agentRef.sharedAggregator.storeMetric(type, name, params, value)
+    this.events.addMetric(type, name, params, value)
   }
 
   storeEventMetrics (name, metrics) {
     if (this.blocked) return
     const type = CUSTOM_METRIC
     const params = { name }
-    this.agentRef.sharedAggregator.store(type, name, params, metrics)
+    this.events.add(type, name, params, metrics)
   }
 
   singleChecks () {

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

@@ -8,7 +8,7 @@ import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { handle } from '../../../common/event-emitter/handle'
 import { FEATURE_NAME } 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 { cumulativeLayoutShift } from '../../../common/vitals/cumulative-layout-shift'
 import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint'
@@ -19,7 +19,6 @@ import { largestContentfulPaint } from '../../../common/vitals/largest-contentfu
 import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte'
 import { subscribeToVisibilityChange } from '../../../common/window/page-visibility'
 import { VITAL_NAMES } from '../../../common/vitals/constants'
-import { EventBuffer } from '../../utils/event-buffer'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -30,8 +29,6 @@ export class Aggregate extends AggregateBase {
 
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
-
-    this.timings = new EventBuffer()
     this.curSessEndRecorded = false
 
     registerHandler('docHidden', msTimestamp => this.endCurrentSession(msTimestamp), this.featureName, this.ee)
@@ -60,9 +57,9 @@ export class Aggregate extends AggregateBase {
         this.addTiming(name, value * 1000, attrs)
       }, true) // CLS node should only reports on vis change rather than on every change
 
-      const scheduler = new HarvestScheduler('events', {
-        onFinished: (...args) => this.onHarvestFinished(...args),
-        getPayload: (...args) => this.prepareHarvest(...args)
+      const scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
+        onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
+        getPayload: (options) => this.makeHarvestPayload(options.retry)
       }, this)
       scheduler.startTimer(harvestTimeSeconds)
 
@@ -97,7 +94,7 @@ export class Aggregate extends AggregateBase {
       attrs.cls = cumulativeLayoutShift.current.value
     }
 
-    this.timings.add({
+    this.events.add({
       name,
       value,
       attrs
@@ -106,11 +103,6 @@ export class Aggregate extends AggregateBase {
     handle('pvtAdded', [name, value, attrs], undefined, FEATURE_NAMES.sessionTrace, this.ee)
   }
 
-  onHarvestFinished (result) {
-    if (result.retry && this.timings.held.hasData) this.timings.unhold()
-    else this.timings.held.clear()
-  }
-
   appendGlobalCustomAttributes (timing) {
     var timingAttributes = timing.attrs || {}
 
@@ -123,27 +115,14 @@ export class Aggregate extends AggregateBase {
     })
   }
 
-  // serialize and return current timing data, clear and save current data for retry
-  prepareHarvest (options) {
-    if (!this.timings.hasData) return
-
-    var payload = this.getPayload(this.timings.buffer)
-    if (options.retry) this.timings.hold()
-    else this.timings.clear()
-
-    return {
-      body: { e: payload }
-    }
-  }
-
   // serialize array of timing data
-  getPayload (data) {
+  serializer (eventBuffer) {
     var addString = getAddStringContext(this.agentIdentifier)
 
     var payload = 'bel.6;'
 
-    for (var i = 0; i < data.length; i++) {
-      var timing = data[i]
+    for (var i = 0; i < eventBuffer.length; i++) {
+      var timing = eventBuffer[i]
 
       payload += 'e,'
       payload += addString(timing.name) + ','
@@ -156,7 +135,7 @@ export class Aggregate extends AggregateBase {
         payload += numeric(attrParts.length) + ';' + attrParts.join(';')
       }
 
-      if ((i + 1) < data.length) payload += ';'
+      if ((i + 1) < eventBuffer.length) payload += ';'
     }
 
     return payload

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

@@ -16,7 +16,7 @@ import { warn } from '../../../common/util/console'
 import { globalScope } from '../../../common/constants/runtime'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { handle } from '../../../common/event-emitter/handle'
-import { FEATURE_NAMES } from '../../../loaders/features/features'
+import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
 import { RRWEB_VERSION } from '../../../common/constants/env'
 import { MODE, SESSION_EVENTS, SESSION_EVENT_TYPES } from '../../../common/session/constants'
 import { stringify } from '../../../common/util/stringify'
@@ -54,14 +54,6 @@ export class Aggregate extends AggregateBase {
 
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, this.ee)
 
-    this.ee.on(`cfc.${FEATURE_NAMES.jserrors}`, (crossFeatureData) => {
-      crossFeatureData.hasReplay = !!(this.scheduler?.started &&
-        this.recorder &&
-        this.mode === MODE.FULL &&
-        !this.blocked &&
-        this.entitled)
-    })
-
     // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
     this.ee.on(SESSION_EVENTS.RESET, () => {
       this.abort(ABORT_REASONS.RESET)
@@ -85,10 +77,10 @@ export class Aggregate extends AggregateBase {
     })
 
     // Bespoke logic for blobs endpoint.
-    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),
       retryDelay: this.harvestTimeSeconds,
-      getPayload: this.prepareHarvest.bind(this),
+      getPayload: ({ retry, ...opts }) => this.makeHarvestPayload(retry, opts),
       raw: true
     }, this)
 
@@ -134,6 +126,10 @@ export class Aggregate extends AggregateBase {
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/ErrorSamplingRate/Value', error_sampling_rate], undefined, FEATURE_NAMES.metrics, this.ee)
   }
 
+  replayIsActive () {
+    return Boolean(this.scheduler?.started && this.recorder && this.mode === MODE.FULL && !this.blocked && this.entitled)
+  }
+
   handleError (e) {
     if (this.recorder) this.recorder.currentBufferTarget.hasError = true
     // run once
@@ -236,7 +232,7 @@ export class Aggregate extends AggregateBase {
     }
   }
 
-  prepareHarvest ({ opts } = {}) {
+  makeHarvestPayload (shouldRetryOnFail, opts) {
     if (!this.recorder || !this.timeKeeper?.ready || !this.recorder.hasSeenSnapshot) return
     const recorderEvents = this.recorder.getEvents()
     // get the event type and use that to trigger another harvest if needed
@@ -365,7 +361,7 @@ export class Aggregate extends AggregateBase {
     }
   }
 
-  onHarvestFinished (result) {
+  postHarvestCleanup (result) {
     // The mutual decision for now is to stop recording and clear buffers if ingest is experiencing 429 rate limiting
     if (result.status === 429) {
       this.abort(ABORT_REASONS.TOO_MANY)

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

@@ -24,11 +24,11 @@ export class RecorderEvents {
   }
 
   get events () {
-    return this.#events.buffer
+    return this.#events.get()
   }
 
   /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
   get payloadBytesEstimation () {
-    return this.#events.bytes
+    return this.#events.byteSize()
   }
 }

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 })