@newrelic/browser-agent 1.271.0 → 1.273.0

package/dist/esm/features/session_replay/shared/recorder-events.js

@@ -21,11 +21,11 @@ export class RecorderEvents {
     this.#events.add(event);
   }
   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/dist/esm/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
 /** Reserved room for query param attrs */
@@ -15,9 +16,6 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   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;
@@ -26,7 +24,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));
   }
@@ -55,9 +53,9 @@ export class Aggregate extends AggregateBase {
         if (this.sessionId !== sessionState.value || eventType === 'cross-tab' && this.scheduler?.started && sessionState.sessionTraceMode === MODE.OFF) this.abort(2);
       });
       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);
       }
     }
 
@@ -69,21 +67,21 @@ export class Aggregate extends AggregateBase {
      * If it drains later (due to a mode change), data and handlers will instantly drain instead of waiting for the registry. */
     if (this.mode === MODE.OFF) return this.deregisterDrain();
     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();else {
@@ -104,32 +102,38 @@ export class Aggregate extends AggregateBase {
     this.scheduler.runHarvest();
     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'];
-    this.everHarvested = 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;
 
-    /** 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
@@ -138,61 +142,45 @@ 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: "".concat(this.agentRef.runtime.session?.state.value, "_").concat(this.agentRef.runtime.ptid, "_").concat(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: "".concat(this.ptid),
-          session: "".concat(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')
+      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: "".concat(this.agentRef.runtime.session.state.value, "_").concat(this.agentRef.runtime.ptid, "_").concat(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: "".concat(this.ptid),
+        session: "".concat(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 '&'
     };
   }
 
-  /** 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;
-    }
-  }
-
   /** Switch from "off" or "error" to full mode (if entitled) */
   switchToFull() {
     if (this.mode === MODE.FULL || !this.entitled || this.blocked) return;
@@ -203,18 +191,19 @@ export class Aggregate extends AggregateBase {
     });
     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/dist/esm/features/session_trace/aggregate/trace/storage.js

@@ -35,8 +35,8 @@ export class TraceStorage {
   trace = {};
   earliestTimeStamp = Infinity;
   latestTimeStamp = 0;
-  tempStorage = [];
   prevStoredEvents = new Set();
+  #backupTrace;
   constructor(parent) {
     this.parent = parent;
   }
@@ -50,9 +50,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];
     if (stn.s < this.earliestTimeStamp) this.earliestTimeStamp = stn.s;
     if (stn.s > this.latestTimeStamp) this.latestTimeStamp = stn.s;
@@ -99,13 +96,8 @@ 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,
@@ -276,9 +268,26 @@ export class TraceStorage {
     if (type !== 'xhr') return;
     this.storeSTN(new TraceNode('Ajax', metrics.time, metrics.time + metrics.duration, "".concat(params.status, " ").concat(params.method, ": ").concat(params.host).concat(params.pathname), 'ajax'));
   }
-  restoreNode(name, listOfSTNodes) {
-    if (this.nodeCount >= MAX_NODES_PER_HARVEST) return;
-    this.nodeCount += listOfSTNodes.length;
-    this.trace[name] = this.trace[name] ? listOfSTNodes.concat(this.trace[name]) : listOfSTNodes;
+
+  /* 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)));
+  }
+  clearSave() {
+    this.#backupTrace = undefined;
   }
 }

package/dist/esm/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);
     timeToFirstByte.subscribe(({
@@ -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
@@ -63,26 +62,16 @@ export class Aggregate extends AggregateBase {
     registerHandler('ajax', this.#handleAjaxEvent.bind(this), this.featureName, this.ee);
     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;".concat(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;".concat(serializedIxnList.join(';'));
   }
   startUIInteraction(eventName, startedAt, sourceElem) {
     // this is throttled by instrumentation so that it isn't excessively called
@@ -130,9 +119,10 @@ 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--) {
+    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 = this.interactionsToHarvest.buffer[idx];
+      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/dist/esm/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,11 @@ 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);
     historyEE.on('replaceState-end', trackURLChange);
@@ -53,13 +56,6 @@ export class Instrument extends InstrumentBase {
     }, 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/dist/esm/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,
@@ -46,7 +45,7 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
-    this.state = {
+    const state = this.state = {
       initialPageURL: initialLocation,
       lastSeenUrl: initialLocation,
       lastSeenRouteName: null,
@@ -60,16 +59,12 @@ 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');
     const promiseEE = baseEE.get('promise');
@@ -115,11 +110,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;
@@ -610,20 +605,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;
@@ -670,7 +651,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';else if (interaction.routeChange) smCategory = 'RouteChange';else smCategory = 'Custom';
       handle(SUPPORTABILITY_METRIC_CHANNEL, ["Spa/Interaction/".concat(smCategory, "/Duration/Ms"), Math.max((interaction.root?.end || 0) - (interaction.root?.start || 0), 0)], undefined, FEATURE_NAMES.metrics, baseEE);
@@ -678,4 +659,7 @@ export class Aggregate extends AggregateBase {
       if (!scheduler) warn(19);
     }
   }
+  serializer(eventBuffer) {
+    return this.spaSerializerClass.serializeMultiple(eventBuffer, 0, navTiming);
+  }
 }

package/dist/esm/features/utils/aggregate-base.js

@@ -5,10 +5,16 @@ 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;
   }
@@ -45,6 +51,37 @@ 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.