@newrelic/browser-agent 1.271.0 → 1.273.0

package/dist/cjs/features/session_trace/aggregate/index.js

@@ -13,6 +13,7 @@ var _encode = require("../../../common/url/encode");
 var _runtime = require("../../../common/constants/runtime");
 var _constants2 = require("../../../common/session/constants");
 var _traverse = require("../../../common/util/traverse");
+var _features = require("../../../loaders/features/features");
 var _cleanUrl = require("../../../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 */
@@ -21,9 +22,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, _constants.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;
@@ -32,7 +30,7 @@ class Aggregate extends _aggregateBase.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 _storage.TraceStorage(this);
+    this.events = new _storage.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));
   }
@@ -61,9 +59,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
         if (this.sessionId !== sessionState.value || eventType === 'cross-tab' && this.scheduler?.started && sessionState.sessionTraceMode === _constants2.MODE.OFF) this.abort(2);
       });
       if (typeof PerformanceNavigationTiming !== 'undefined') {
-        this.traceStorage.storeTiming(_runtime.globalScope.performance?.getEntriesByType?.('navigation')[0]);
+        this.events.storeTiming(_runtime.globalScope.performance?.getEntriesByType?.('navigation')[0]);
       } else {
-        this.traceStorage.storeTiming(_runtime.globalScope.performance?.timing, true);
+        this.events.storeTiming(_runtime.globalScope.performance?.timing, true);
       }
     }
 
@@ -75,21 +73,21 @@ class Aggregate extends _aggregateBase.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 === _constants2.MODE.OFF) return this.deregisterDrain();
     this.timeKeeper ??= this.agentRef.runtime.timeKeeper;
-    this.scheduler = new _harvestScheduler.HarvestScheduler('browser/blobs', {
-      onFinished: this.onHarvestFinished.bind(this),
+    this.scheduler = new _harvestScheduler.HarvestScheduler(_features.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 */
-    (0, _registerHandler.registerHandler)('bst', (...args) => this.traceStorage.storeEvent(...args), this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('bstResource', (...args) => this.traceStorage.storeResources(...args), this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('bstHist', (...args) => this.traceStorage.storeHist(...args), this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('bstXhrAgg', (...args) => this.traceStorage.storeXhrAgg(...args), this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('bstApi', (...args) => this.traceStorage.storeSTN(...args), this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('trace-jserror', (...args) => this.traceStorage.storeErrorAgg(...args), this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('pvtAdded', (...args) => this.traceStorage.processPVT(...args), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('bst', (...args) => this.events.storeEvent(...args), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('bstResource', (...args) => this.events.storeResources(...args), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('bstHist', (...args) => this.events.storeHist(...args), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('bstXhrAgg', (...args) => this.events.storeXhrAgg(...args), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('bstApi', (...args) => this.events.storeSTN(...args), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('trace-jserror', (...args) => this.events.storeErrorAgg(...args), this.featureName, this.ee);
+    (0, _registerHandler.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 === _constants2.MODE.FULL) this.startHarvesting();else {
@@ -110,32 +108,38 @@ class Aggregate extends _aggregateBase.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 !== _constants2.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 !== _constants2.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 (0, _traverse.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
@@ -144,61 +148,45 @@ class Aggregate extends _aggregateBase.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: (0, _encode.obj)({
-          ...(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((0, _cleanUrl.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: (0, _traverse.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: (0, _encode.obj)({
+        ...(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((0, _cleanUrl.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 === _constants2.MODE.FULL || !this.entitled || this.blocked) return;
@@ -209,19 +197,20 @@ class Aggregate extends _aggregateBase.AggregateBase {
     });
     if (prevMode === _constants2.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 = _constants2.MODE.OFF;
     this.agentRef.runtime.session.write({
       sessionTraceMode: this.mode
     });
     this.scheduler?.stopTimer();
+    this.events.clear();
   }
 }
 exports.Aggregate = Aggregate;

package/dist/cjs/features/session_trace/aggregate/trace/storage.js

@@ -41,8 +41,8 @@ class TraceStorage {
   trace = {};
   earliestTimeStamp = Infinity;
   latestTimeStamp = 0;
-  tempStorage = [];
   prevStoredEvents = new Set();
+  #backupTrace;
   constructor(parent) {
     this.parent = parent;
   }
@@ -56,9 +56,6 @@ 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;
@@ -105,13 +102,8 @@ 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,
@@ -282,10 +274,27 @@ class TraceStorage {
     if (type !== 'xhr') return;
     this.storeSTN(new _node.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 >= _constants2.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;
   }
 }
 exports.TraceStorage = TraceStorage;

package/dist/cjs/features/soft_navigations/aggregate/index.js

@@ -12,7 +12,6 @@ var _timeToFirstByte = require("../../../common/vitals/time-to-first-byte");
 var _features = require("../../../loaders/features/features");
 var _constants = require("../../metrics/constants");
 var _aggregateBase = require("../../utils/aggregate-base");
-var _eventBuffer = require("../../utils/event-buffer");
 var _constants2 = require("../constants");
 var _ajaxNode = require("./ajax-node");
 var _initialPageLoadInteraction = require("./initial-page-load-interaction");
@@ -24,7 +23,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
   }) {
     super(agentRef, _constants2.FEATURE_NAME);
     const harvestTimeSeconds = agentRef.init.soft_navigations.harvestTimeSeconds || 10;
-    this.interactionsToHarvest = new _eventBuffer.EventBuffer();
+    this.interactionsToHarvest = this.events;
     this.domObserver = domObserver;
     this.initialPageLoadInteraction = new _initialPageLoadInteraction.InitialPageLoadInteraction(agentRef.agentIdentifier);
     _timeToFirstByte.timeToFirstByte.subscribe(({
@@ -45,12 +44,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.waitForFlags(['spa']).then(([spaOn]) => {
       if (spaOn) {
         this.drain();
-        const scheduler = new _harvestScheduler.HarvestScheduler('events', {
-          onFinished: this.onHarvestFinished.bind(this),
+        const scheduler = new _harvestScheduler.HarvestScheduler(_features.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
@@ -69,26 +68,16 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _registerHandler.registerHandler)('ajax', this.#handleAjaxEvent.bind(this), this.featureName, this.ee);
     (0, _registerHandler.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
@@ -136,9 +125,10 @@ class Aggregate extends _aggregateBase.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/cjs/features/soft_navigations/instrument/index.js

@@ -9,7 +9,6 @@ var _runtime = require("../../../common/constants/runtime");
 var _handle = require("../../../common/event-emitter/handle");
 var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
 var _invoke = require("../../../common/util/invoke");
-var _wrapEvents = require("../../../common/wrap/wrap-events");
 var _wrapHistory = require("../../../common/wrap/wrap-history");
 var _instrumentBase = require("../../utils/instrument-base");
 var _constants = require("../constants");
@@ -28,7 +27,11 @@ class Instrument extends _instrumentBase.InstrumentBase {
     if (!_runtime.isBrowserScope || !(0, _nreum.gosNREUMOriginals)().o.MO) return; // soft navigations is not supported outside web env or browsers without the mutation observer API
 
     const historyEE = (0, _wrapHistory.wrapHistory)(this.ee);
-    const eventsEE = (0, _wrapEvents.wrapEvents)(this.ee);
+    _constants.INTERACTION_TRIGGERS.forEach(trigger => {
+      (0, _eventListenerOpts.windowAddEventListener)(trigger, evt => {
+        processUserInteraction(evt);
+      }, true);
+    });
     const trackURLChange = () => (0, _handle.handle)('newURL', [(0, _now.now)(), '' + window.location], undefined, this.featureName, this.ee);
     historyEE.on('pushState-end', trackURLChange);
     historyEE.on('replaceState-end', trackURLChange);
@@ -58,13 +61,6 @@ class Instrument extends _instrumentBase.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 (_constants.INTERACTION_TRIGGERS.includes(evt?.type)) {
-        processUserInteraction(evt);
-      }
-    });
-    for (let eventType of _constants.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/cjs/features/spa/aggregate/index.js

@@ -24,7 +24,6 @@ var _runtime = require("../../../common/constants/runtime");
 var _handle = require("../../../common/event-emitter/handle");
 var _constants2 = require("../../metrics/constants");
 var _console = require("../../../common/util/console");
-var _eventBuffer = require("../../utils/event-buffer");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /*
@@ -55,7 +54,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
-    this.state = {
+    const state = this.state = {
       initialPageURL: _runtime.initialLocation,
       lastSeenUrl: _runtime.initialLocation,
       lastSeenRouteName: null,
@@ -69,16 +68,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
       childTime: 0,
       depth: 0,
       harvestTimeSeconds: agentRef.init.spa.harvestTimeSeconds || 10,
-      interactionsToHarvest: new _eventBuffer.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.Serializer(this);
+    const classThis = this;
     let scheduler;
-    this.serializer = new _serializer.Serializer(this);
-    const {
-      state,
-      serializer
-    } = this;
     const baseEE = _contextualEe.ee.get(agentRef.agentIdentifier); // <-- parent baseEE
     const mutationEE = baseEE.get('mutation');
     const promiseEE = baseEE.get('promise');
@@ -124,11 +119,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
     this.waitForFlags(['spa']).then(([spaFlag]) => {
       if (spaFlag) {
-        scheduler = new _harvestScheduler.HarvestScheduler('events', {
-          onFinished: onHarvestFinished,
+        scheduler = new _harvestScheduler.HarvestScheduler(_features.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;
@@ -619,20 +614,6 @@ class Aggregate extends _aggregateBase.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.navTimingValues);
-      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;
@@ -679,7 +660,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         interaction.root.attrs.firstContentfulPaint = _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';
       (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ["Spa/Interaction/".concat(smCategory, "/Duration/Ms"), Math.max((interaction.root?.end || 0) - (interaction.root?.start || 0), 0)], undefined, _features.FEATURE_NAMES.metrics, baseEE);
@@ -687,5 +668,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
       if (!scheduler) (0, _console.warn)(19);
     }
   }
+  serializer(eventBuffer) {
+    return this.spaSerializerClass.serializeMultiple(eventBuffer, 0, _navTiming.navTimingValues);
+  }
 }
 exports.Aggregate = Aggregate;

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

@@ -11,10 +11,16 @@ var _nreum = require("../../common/window/nreum");
 var _drain = require("../../common/drain/drain");
 var _featureFlags = require("../../common/util/feature-flags");
 var _obfuscate = require("../../common/util/obfuscate");
+var _eventBuffer = require("./event-buffer");
+var _features = require("../../loaders/features/features");
 class AggregateBase extends _featureBase.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 ([_features.FEATURE_NAMES.jserrors, _features.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 (![_features.FEATURE_NAMES.pageViewEvent, _features.FEATURE_NAMES.sessionTrace].includes(this.featureName)) this.events = new _eventBuffer.EventBuffer();
     this.checkConfiguration(agentRef);
     this.obfuscator = agentRef.runtime.obfuscator;
   }
@@ -51,6 +57,37 @@ class AggregateBase extends _featureBase.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.