@newrelic/browser-agent 1.252.0 → 1.253.0

package/dist/esm/common/event-emitter/contextual-ee.js

@@ -6,11 +6,9 @@
 import { gosNREUM } from '../window/nreum';
 import { getOrSet } from '../util/get-or-set';
 import { getRuntime } from '../config/config';
-import { EventContext } from './event-context';
-import { bundleId } from '../ids/bundle-id';
+import { EventContext } from '../context/event-context';
+import { ObservationContextManager } from '../context/observation-context-manager';
 
-// create a unique id to store event context data for the current agent bundle
-const contextId = "nr@context:".concat(bundleId);
 // create global emitter instance that can be shared among bundles
 const globalInstance = ee(undefined, 'globalEE');
 
@@ -19,7 +17,7 @@ const nr = gosNREUM();
 if (!nr.ee) {
   nr.ee = globalInstance;
 }
-export { globalInstance as ee, contextId };
+export { globalInstance as ee };
 function ee(old, debugId) {
   var handlers = {};
   var bufferGroupMap = {};
@@ -49,16 +47,17 @@ function ee(old, debugId) {
     aborted: false,
     isBuffering,
     debugId,
-    backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {}
+    backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {},
+    observationContextManager: null
   };
   return emitter;
   function context(contextOrStore) {
     if (contextOrStore && contextOrStore instanceof EventContext) {
       return contextOrStore;
     } else if (contextOrStore) {
-      return getOrSet(contextOrStore, contextId, () => new EventContext(contextId));
+      return getOrSet(contextOrStore, ObservationContextManager.contextId, () => emitter.observationContextManager ? emitter.observationContextManager.getCreateContext(contextOrStore) : new EventContext(ObservationContextManager.contextId));
     } else {
-      return new EventContext(contextId);
+      return emitter.observationContextManager ? emitter.observationContextManager.getCreateContext({}) : new EventContext(ObservationContextManager.contextId);
     }
   }
   function emit(type, args, contextOrStore, force, bubble) {
@@ -102,7 +101,11 @@ function ee(old, debugId) {
     return handlers[type] || [];
   }
   function getOrCreate(name) {
-    return emitters[name] = emitters[name] || ee(emitter, name);
+    const newEventEmitter = emitters[name] = emitters[name] || ee(emitter, name);
+    if (!newEventEmitter.observationContextManager && emitter.observationContextManager) {
+      newEventEmitter.observationContextManager = emitter.observationContextManager;
+    }
+    return newEventEmitter;
   }
   function bufferEventsByGroup(types, group) {
     const eventBuffer = getBuffer();

package/dist/esm/common/session/constants.js

@@ -1,4 +1,5 @@
 export const PREFIX = 'NRBA';
+export const DEFAULT_KEY = 'SESSION';
 export const DEFAULT_EXPIRES_MS = 14400000;
 export const DEFAULT_INACTIVE_MS = 1800000;
 export const SESSION_EVENTS = {

package/dist/esm/common/session/session-entity.js

@@ -130,7 +130,9 @@ export class SessionEntity {
 
     // The fact that the session is "new" or pre-existing is used in some places in the agent.  Session Replay and Trace
     // can use this info to inform whether to trust a new sampling decision vs continue a previous tracking effort.
-    this.isNew = !Object.keys(initialRead).length;
+    /* [NR-230914] 02/2024 - the logical OR assignment is used so that isNew remains 'true' if it was already set as such. This fixes the expires and inactive timestamps timing out in localStorage
+      while no page for a given domain is in-use and the session resetting upon user returning to the page as part of a fresh session. */
+    this.isNew ||= !Object.keys(initialRead).length;
     // if its a "new" session, we write to storage API with the default values.  These values may change over the lifespan of the agent run.
     // we can use a modeled object here to help us know and manage what values are being used. -- see "model" above
     if (this.isNew) this.write(getModeledObject(this.state, model), true);else this.sync(initialRead);

package/dist/esm/common/timing/nav-timing.js

@@ -24,7 +24,7 @@ var REQUEST = 'request';
 var RESPONSE = 'response';
 var LOAD_EVENT = 'loadEvent';
 var DOM_CONTENT_LOAD_EVENT = 'domContentLoadedEvent';
-export var navTimingValues = [];
+export const navTimingValues = [];
 function getPntType(type) {
   if (typeof type === 'number') return type;
   const types = {
@@ -70,6 +70,11 @@ export function addPN(pn, v) {
   handleValue(pn.redirectCount, v, 'rc');
   return v;
 }
+
+/**
+ * By side effect, this modifies 'obj' with a mapping of the 'prop' provided to a 'value', and invalid values are not added.
+ * On the other hand, the local navTimingValues array gets the value appended if valid and 'undefined' appended if invalid, regardless.
+ */
 function handleValue(value, obj, prop, isOldApi) {
   /*
   For L2 Timing API, the value will already be a relative-to-previous-document DOMHighResTimeStamp.
@@ -84,6 +89,6 @@ function handleValue(value, obj, prop, isOldApi) {
     }
     value = Math.round(value);
     obj[prop] = value;
-  }
-  navTimingValues.push(value);
+    navTimingValues.push(value);
+  } else navTimingValues.push(undefined);
 }

package/dist/esm/common/timing/now.js

@@ -5,5 +5,5 @@
 
 // This is our own layer around performance.now. It's not strictly necessary, but we keep it in case of future mod-ing of the value for refactor purpose.
 export function now() {
-  return Math.round(performance.now());
+  return Math.floor(performance.now());
 }

package/dist/esm/common/util/feature-flags.js

@@ -10,7 +10,7 @@ const bucketMap = {
   stn: [FEATURE_NAMES.sessionTrace],
   err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
   ins: [FEATURE_NAMES.pageAction],
-  spa: [FEATURE_NAMES.spa],
+  spa: [FEATURE_NAMES.spa, FEATURE_NAMES.softNav],
   sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
 };
 const sentIds = new Set();

package/dist/esm/common/wrap/index.js

@@ -8,7 +8,6 @@ import { wrapHistory } from './wrap-history';
 import { wrapJsonP } from './wrap-jsonp';
 import { wrapMutation } from './wrap-mutation';
 import { wrapPromise } from './wrap-promise';
-import { wrapRaf } from './wrap-raf';
 import { wrapTimer } from './wrap-timer';
 import { wrapXhr } from './wrap-xhr';
-export { wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapRaf, wrapTimer, wrapXhr };
+export { wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapTimer, wrapXhr };

package/dist/esm/common/wrap/wrap-events.js

@@ -7,15 +7,15 @@
  * This module is used directly by: session_trace.
  * It is also called by -> wrapXhr <-, so see "wrap-xhr.js" for features that use this indirectly.
  */
-import { ee as baseEE, contextId } from '../event-emitter/contextual-ee';
+import { ee as baseEE } from '../event-emitter/contextual-ee';
 import { createWrapperWithEmitter as wfn } from './wrap-function';
 import { getOrSet } from '../util/get-or-set';
 import { globalScope, isBrowserScope } from '../constants/runtime';
+import { ObservationContextManager } from '../context/observation-context-manager';
 const wrapped = {};
 const XHR = globalScope.XMLHttpRequest;
 const ADD_EVENT_LISTENER = 'addEventListener';
 const REMOVE_EVENT_LISTENER = 'removeEventListener';
-const flag = "nr@wrapped:".concat(contextId);
 
 /**
  * Wraps `addEventListener` and `removeEventListener` on: global scope; the prototype of `XMLHttpRequest`, and
@@ -44,7 +44,7 @@ export function wrapEvents(sharedEE) {
     if (originalListener === null || typeof originalListener !== 'function' && typeof originalListener !== 'object') {
       return;
     }
-    var wrapped = getOrSet(originalListener, flag, function () {
+    var wrapped = getOrSet(originalListener, ObservationContextManager.contextWrappedId, function () {
       var listener = {
         object: wrapHandleEvent,
         function: originalListener

package/dist/esm/common/wrap/wrap-fetch.js

@@ -6,8 +6,9 @@
  * @file Wraps `fetch` and related methods for instrumentation.
  * This module is used by: ajax, spa.
  */
-import { ee as baseEE, contextId } from '../event-emitter/contextual-ee';
+import { ee as baseEE } from '../event-emitter/contextual-ee';
 import { globalScope } from '../constants/runtime';
+import { ObservationContextManager } from '../context/observation-context-manager';
 var prefix = 'fetch-';
 var bodyPrefix = prefix + 'body-';
 var bodyMethods = ['arrayBuffer', 'blob', 'json', 'text', 'formData'];
@@ -70,7 +71,7 @@ export function wrapFetch(sharedEE) {
         // we are wrapping args in an array so we can preserve the reference
         ee.emit(prefix + 'before-start', [args], ctx);
         var dtPayload;
-        if (ctx[contextId] && ctx[contextId].dt) dtPayload = ctx[contextId].dt;
+        if (ctx[ObservationContextManager.contextId] && ctx[ObservationContextManager.contextId].dt) dtPayload = ctx[ObservationContextManager.contextId].dt;
         var origPromiseFromFetch = fn.apply(this, args);
         ee.emit(prefix + 'start', [args, dtPayload], origPromiseFromFetch);
 

package/dist/esm/common/wrap/wrap-function.js

@@ -7,8 +7,7 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee';
-import { bundleId } from '../ids/bundle-id';
-export const flag = "nr@original:".concat(bundleId);
+import { ObservationContextManager } from '../context/observation-context-manager';
 
 /**
  * A convenience alias of `hasOwnProperty`.
@@ -40,7 +39,7 @@ export function createWrapperWithEmitter(emitter, always) {
    * As a property on a wrapped function, contains the original function.
    * @type {string}
    */
-  wrapFn.flag = flag;
+  wrapFn.flag = ObservationContextManager.contextOriginalId;
   return wrapFn;
 
   /**
@@ -56,7 +55,7 @@ export function createWrapperWithEmitter(emitter, always) {
     // Unless fn is both wrappable and unwrapped, return it unchanged.
     if (notWrappable(fn)) return fn;
     if (!prefix) prefix = '';
-    nrWrapper[flag] = fn;
+    nrWrapper[ObservationContextManager.contextOriginalId] = fn;
     copy(fn, nrWrapper, emitter);
     return nrWrapper;
 
@@ -210,5 +209,5 @@ function copy(from, to, emitter) {
  * @returns {boolean} Whether the passed function is ineligible to be wrapped.
  */
 function notWrappable(fn) {
-  return !(fn && typeof fn === 'function' && fn.apply && !fn[flag]);
+  return !(fn && typeof fn === 'function' && fn.apply && !fn[ObservationContextManager.contextOriginalId]);
 }

package/dist/esm/common/wrap/wrap-promise.js

@@ -7,9 +7,10 @@
  * This module is used by: spa.
  */
 
-import { createWrapperWithEmitter as wrapFn, flag } from './wrap-function';
+import { createWrapperWithEmitter as wrapFn } from './wrap-function';
 import { ee as baseEE } from '../event-emitter/contextual-ee';
 import { globalScope } from '../constants/runtime';
+import { ObservationContextManager } from '../context/observation-context-manager';
 const wrapped = {};
 
 /**
@@ -118,7 +119,7 @@ export function wrapPromise(sharedEE) {
       promiseEE.emit('propagate', [originalThis, true], origFnCallWithThis, false, false);
       return origFnCallWithThis;
     };
-    prevPromiseObj.prototype.then[flag] = prevPromiseOrigThen;
+    prevPromiseObj.prototype.then[ObservationContextManager.contextOriginalId] = prevPromiseOrigThen;
     promiseEE.on('executor-start', function (args) {
       args[0] = promiseWrapper(args[0], 'resolve-', this, null, false);
       args[1] = promiseWrapper(args[1], 'resolve-', this, null, false);

package/dist/esm/features/ajax/aggregate/index.js

@@ -2,7 +2,7 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { registerHandler as register } from '../../../common/event-emitter/register-handler';
+import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { stringify } from '../../../common/util/stringify';
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
 import { handle } from '../../../common/event-emitter/handle';
@@ -14,13 +14,14 @@ import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { parseGQL } from './gql';
+import { getNREUMInitializedAgent } from '../../../common/window/nreum';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
     const agentInit = getConfiguration(agentIdentifier);
     const allAjaxIsEnabled = agentInit.ajax.enabled !== false;
-    register('xhr', storeXhr, this.featureName, this.ee);
+    registerHandler('xhr', storeXhr, this.featureName, this.ee);
     if (!allAjaxIsEnabled) {
       this.drain();
       return; // feature will only collect timeslice metrics & ajax trace nodes if it's not fully enabled
@@ -43,19 +44,23 @@ export class Aggregate extends AggregateBase {
         spaAjaxEvents
       };
     };
-    ee.on('interactionSaved', interaction => {
-      if (!spaAjaxEvents[interaction.id]) return;
-      // remove from the spaAjaxEvents buffer, and let spa harvest it
-      delete spaAjaxEvents[interaction.id];
-    });
-    ee.on('interactionDiscarded', interaction => {
+
+    // --- v Used by old spa feature
+    ee.on('interactionDone', (interaction, wasSaved) => {
       if (!spaAjaxEvents[interaction.id]) return;
-      spaAjaxEvents[interaction.id].forEach(function (item) {
-        // move it from the spaAjaxEvents buffer to the ajaxEvents buffer for harvesting here
-        ajaxEvents.push(item);
-      });
+      if (!wasSaved) {
+        // if the ixn was saved, then its ajax reqs are part of the payload whereas if it was discarded, it should still be harvested in the ajax feature itself
+        spaAjaxEvents[interaction.id].forEach(function (item) {
+          ajaxEvents.push(item);
+        });
+      }
       delete spaAjaxEvents[interaction.id];
     });
+    // --- ^
+    // --- v Used by new soft nav
+    registerHandler('returnAjax', event => ajaxEvents.push(event), this.featureName, this.ee);
+    // --- ^
+
     const scheduler = new HarvestScheduler('events', {
       onFinished: onEventsHarvestFinished,
       getPayload: prepareHarvest
@@ -76,16 +81,26 @@ export class Aggregate extends AggregateBase {
       } else {
         hash = stringify([params.status, params.host, params.pathname]);
       }
+      const shouldCollect = shouldCollectEvent(params);
+      const ajaxMetricDenyListEnabled = agentInit.feature_flags?.includes('ajax_metrics_deny_list');
 
       // store as metric
-      aggregator.store('xhr', hash, params, metrics);
+      if (shouldCollect || !ajaxMetricDenyListEnabled) {
+        aggregator.store('xhr', hash, params, metrics);
+      }
       if (!allAjaxIsEnabled) return;
-      if (!shouldCollectEvent(params)) {
+      if (!shouldCollect) {
         if (params.hostname === beacon || proxyBeacon && params.hostname === proxyBeacon) {
           // This doesn't make a distinction if the same-domain request is going to a different port or path...
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee);
+          if (ajaxMetricDenyListEnabled) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee);
+          }
         } else {
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee);
+          if (ajaxMetricDenyListEnabled) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee);
+          }
         }
         return;
       }
@@ -115,10 +130,13 @@ export class Aggregate extends AggregateBase {
         query: this?.parsedOrigin?.search
       });
       if (event.gql) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length], undefined, FEATURE_NAMES.metrics, ee);
-
-      // if the ajax happened inside an interaction, hold it until the interaction finishes
-      if (this.spaNode) {
-        var interactionId = this.spaNode.interaction.id;
+      const softNavInUse = Boolean(getNREUMInitializedAgent(agentIdentifier)?.features?.[FEATURE_NAMES.softNav]);
+      if (softNavInUse) {
+        // For newer soft nav (when running), pass the event to it for evaluation -- either part of an interaction or is given back
+        handle('ajax', [event], undefined, FEATURE_NAMES.softNav, ee);
+      } else if (this.spaNode) {
+        // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
+        const interactionId = this.spaNode.interaction.id;
         spaAjaxEvents[interactionId] = spaAjaxEvents[interactionId] || [];
         spaAjaxEvents[interactionId].push(event);
       } else {

package/dist/esm/features/jserrors/aggregate/index.js

@@ -18,6 +18,7 @@ import { globalScope } from '../../../common/constants/runtime';
 import { FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { AggregateBase } from '../../utils/aggregate-base';
+import { getNREUMInitializedAgent } from '../../../common/window/nreum';
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
@@ -32,21 +33,20 @@ export class Aggregate extends AggregateBase {
     this.stackReported = {};
     this.observedAt = {};
     this.pageviewReported = {};
-    this.errorCache = {};
+    this.bufferedErrorsUnderSpa = {};
     this.currentBody = undefined;
     this.errorOnPage = false;
 
     // this will need to change to match whatever ee we use in the instrument
-    this.ee.on('interactionSaved', interaction => this.onInteractionSaved(interaction));
-
-    // this will need to change to match whatever ee we use in the instrument
-    this.ee.on('interactionDiscarded', interaction => this.onInteractionDiscarded(interaction));
+    this.ee.on('interactionDone', (interaction, wasSaved) => this.onInteractionDone(interaction, wasSaved));
     register('err', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
     register('ierr', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
+    register('softNavFlush', (interactionId, wasFinished, softNavAttrs) => this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs), this.featureName, this.ee); // when an ixn is done or cancelled
+
     const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10;
     const scheduler = new HarvestScheduler('jserrors', {
       onFinished: function () {
@@ -188,81 +188,92 @@ export class Aggregate extends AggregateBase {
       time
     };
 
-    // sr, stn and spa aggregators listen to this event - stn sends the error in its payload,
-    // and spa annotates the error with interaction info
-    const msg = [type, bucketHash, params, newMetrics];
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionTrace, this.ee);
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.spa, this.ee);
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionReplay, this.ee);
-
+    // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
+    const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes];
+    handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee);
+    handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.sessionReplay, this.ee);
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return;
-    var att = getInfo(this.agentIdentifier).jsAttributes;
-    if (params._interactionId != null) {
-      // hold on to the error until the interaction finishes
-      this.errorCache[params._interactionId] = this.errorCache[params._interactionId] || [];
-      this.errorCache[params._interactionId].push([type, bucketHash, params, newMetrics, att, customAttributes]);
+    const softNavInUse = Boolean(getNREUMInitializedAgent(this.agentIdentifier)?.features[FEATURE_NAMES.softNav]);
+    // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
+    // They each will also tack on their respective properties to the params object as part of the decision flow.
+    if (softNavInUse) handle('jserror', [params, time], undefined, FEATURE_NAMES.softNav, this.ee);else handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.spa, this.ee);
+    if (params.browserInteractionId && !params._softNavFinished) {
+      // hold onto the error until the in-progress interaction is done, eithered saved or discarded
+      this.bufferedErrorsUnderSpa[params.browserInteractionId] ??= [];
+      this.bufferedErrorsUnderSpa[params.browserInteractionId].push(jsErrorEvent);
+    } else if (params._interactionId != null) {
+      // same as above, except tailored for the way old spa does it
+      this.bufferedErrorsUnderSpa[params._interactionId] = this.bufferedErrorsUnderSpa[params._interactionId] || [];
+      this.bufferedErrorsUnderSpa[params._interactionId].push(jsErrorEvent);
     } else {
-      // store custom attributes
-      var customParams = {};
-      mapOwn(att, setCustom);
-      if (customAttributes) {
-        mapOwn(customAttributes, setCustom);
-      }
-      var jsAttributesHash = stringHashCode(stringify(customParams));
-      var aggregateHash = bucketHash + ':' + jsAttributesHash;
-      this.aggregator.store(type, aggregateHash, params, newMetrics, customParams);
+      // Either there is no interaction (then all these params properties will be undefined) OR there's a related soft navigation that's already completed.
+      // The old spa does not look up completed interactions at all, so there's no need to consider it.
+      this.#storeJserrorForHarvest(jsErrorEvent, params.browserInteractionId !== undefined, params._softNavAttributes);
     }
+  }
+  #storeJserrorForHarvest(errorInfoArr, softNavOccurredFinished) {
+    let softNavCustomAttrs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    let [type, bucketHash, params, newMetrics, localAttrs] = errorInfoArr;
+    const allCustomAttrs = {};
+    if (softNavOccurredFinished) {
+      Object.entries(softNavCustomAttrs).forEach(_ref => {
+        let [k, v] = _ref;
+        return setCustom(k, v);
+      }); // when an ixn finishes, it'll include stuff in jsAttributes + attrs specific to the ixn
+      bucketHash += params.browserInteractionId;
+      delete params._softNavAttributes; // cleanup temp properties from synchronous evaluation; this is harmless when async from soft nav (properties DNE)
+      delete params._softNavFinished;
+    } else {
+      // interaction was cancelled -> error should not be associated OR there was no interaction
+      Object.entries(getInfo(this.agentIdentifier).jsAttributes).forEach(_ref2 => {
+        let [k, v] = _ref2;
+        return setCustom(k, v);
+      });
+      delete params.browserInteractionId;
+    }
+    if (localAttrs) Object.entries(localAttrs).forEach(_ref3 => {
+      let [k, v] = _ref3;
+      return setCustom(k, v);
+    }); // local custom attrs are applied in either case with the highest precedence
+
+    const jsAttributesHash = stringHashCode(stringify(allCustomAttrs));
+    const aggregateHash = bucketHash + ':' + jsAttributesHash;
+    this.aggregator.store(type, aggregateHash, params, newMetrics, allCustomAttrs);
     function setCustom(key, val) {
-      customParams[key] = val && typeof val === 'object' ? stringify(val) : val;
+      allCustomAttrs[key] = val && typeof val === 'object' ? stringify(val) : val;
     }
   }
-  onInteractionSaved(interaction) {
-    if (!this.errorCache[interaction.id] || this.blocked) return;
-    this.errorCache[interaction.id].forEach(item => {
-      var customParams = {};
-      var globalCustomParams = item[4];
-      var localCustomParams = item[5];
-      mapOwn(globalCustomParams, setCustom);
-      mapOwn(interaction.root.attrs.custom, setCustom);
-      mapOwn(localCustomParams, setCustom);
+
+  // TO-DO: Remove this function when old spa is taken out. #storeJserrorForHarvest handles the work with the softnav feature.
+  onInteractionDone(interaction, wasSaved) {
+    if (!this.bufferedErrorsUnderSpa[interaction.id] || this.blocked) return;
+    this.bufferedErrorsUnderSpa[interaction.id].forEach(item => {
+      var allCustomAttrs = {};
+      const localCustomAttrs = item[4];
+      mapOwn(interaction.root.attrs.custom, setCustom); // tack on custom attrs from the interaction
+      mapOwn(localCustomAttrs, setCustom);
       var params = item[2];
-      params.browserInteractionId = interaction.root.attrs.id;
-      delete params._interactionId;
-      if (params._interactionNodeId) {
-        params.parentNodeId = params._interactionNodeId.toString();
-        delete params._interactionNodeId;
-      }
-      var hash = item[1] + interaction.root.attrs.id;
-      var jsAttributesHash = stringHashCode(stringify(customParams));
-      var aggregateHash = hash + ':' + jsAttributesHash;
-      this.aggregator.store(item[0], aggregateHash, params, item[3], customParams);
-      function setCustom(key, val) {
-        customParams[key] = val && typeof val === 'object' ? stringify(val) : val;
+      if (wasSaved) {
+        params.browserInteractionId = interaction.root.attrs.id;
+        if (params._interactionNodeId) params.parentNodeId = params._interactionNodeId.toString();
       }
-    });
-    delete this.errorCache[interaction.id];
-  }
-  onInteractionDiscarded(interaction) {
-    if (!this.errorCache || !this.errorCache[interaction.id] || this.blocked) return;
-    this.errorCache[interaction.id].forEach(item => {
-      var customParams = {};
-      var globalCustomParams = item[4];
-      var localCustomParams = item[5];
-      mapOwn(globalCustomParams, setCustom);
-      mapOwn(interaction.root.attrs.custom, setCustom);
-      mapOwn(localCustomParams, setCustom);
-      var params = item[2];
       delete params._interactionId;
       delete params._interactionNodeId;
-      var hash = item[1];
-      var jsAttributesHash = stringHashCode(stringify(customParams));
+      var hash = wasSaved ? item[1] + interaction.root.attrs.id : item[1];
+      var jsAttributesHash = stringHashCode(stringify(allCustomAttrs));
       var aggregateHash = hash + ':' + jsAttributesHash;
-      this.aggregator.store(item[0], aggregateHash, item[2], item[3], customParams);
+      this.aggregator.store(item[0], aggregateHash, params, item[3], allCustomAttrs);
       function setCustom(key, val) {
-        customParams[key] = val && typeof val === 'object' ? stringify(val) : val;
+        allCustomAttrs[key] = val && typeof val === 'object' ? stringify(val) : val;
       }
     });
-    delete this.errorCache[interaction.id];
+    delete this.bufferedErrorsUnderSpa[interaction.id];
+  }
+  onSoftNavNotification(interactionId, wasFinished, softNavAttrs) {
+    if (this.blocked) return;
+    this.bufferedErrorsUnderSpa[interactionId]?.forEach(jsErrorEvent => this.#storeJserrorForHarvest(jsErrorEvent, wasFinished, softNavAttrs) // this should not modify the re-used softNavAttrs contents
+    );
+    delete this.bufferedErrorsUnderSpa[interactionId]; // wipe the list of jserrors so they aren't duplicated by another call to the same id
   }
 }

package/dist/esm/features/page_view_event/aggregate/index.js

@@ -129,7 +129,7 @@ export class Aggregate extends AggregateBase {
           this.drain();
         } catch (err) {
           this.ee.abort();
-          warn('RUM call failed. Agent shutting down.');
+          warn('RUM call failed. Agent shutting down.', err);
         }
       }
     });

package/dist/esm/features/page_view_event/aggregate/initialized-features.js

@@ -25,6 +25,7 @@ export function getActivatedFeaturesFlags(agentId) {
         case FEATURE_NAMES.sessionTrace:
           flagArr.push('stn');
           break;
+        case FEATURE_NAMES.softNav:
         case FEATURE_NAMES.spa:
           flagArr.push('spa');
           break;