@newrelic/browser-agent 1.252.1 → 1.253.0

package/dist/esm/features/soft_navigations/instrument/index.js

@@ -0,0 +1,73 @@
+import { originals } from '../../../common/config/config';
+import { isBrowserScope } from '../../../common/constants/runtime';
+import { handle } from '../../../common/event-emitter/handle';
+import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
+import { now } from '../../../common/timing/now';
+import { debounce } from '../../../common/util/invoke';
+import { wrapEvents, wrapHistory } from '../../../common/wrap';
+import { InstrumentBase } from '../../utils/instrument-base';
+import { FEATURE_NAME, INTERACTION_TRIGGERS } from '../constants';
+
+/** The minimal time after a UI event for which no further events will be processed - i.e. a throttling rate to reduce spam.
+ * This also give some time for the new interaction to complete without being discarded by a subsequent UI event and wrongly attributed.
+ * This value is still subject to change and critique, as it is derived from beyond worst case time to next frame of a page.
+ */
+const UI_WAIT_INTERVAL = 1 / 10 * 1000; // assume 10 fps
+
+export class Instrument extends InstrumentBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    if (!isBrowserScope || !originals.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);
+    const trackURLChange = () => handle('newURL', [now(), '' + window.location], undefined, this.featureName, this.ee);
+    historyEE.on('pushState-end', trackURLChange);
+    historyEE.on('replaceState-end', trackURLChange);
+    try {
+      this.removeOnAbort = new AbortController();
+    } catch (e) {}
+    const trackURLChangeEvent = evt => handle('newURL', [evt.timeStamp, '' + window.location], undefined, this.featureName, this.ee);
+    windowAddEventListener('popstate', trackURLChangeEvent, true, this.removeOnAbort?.signal);
+    let oncePerFrame = false; // attempt to reduce dom noice since the observer runs very frequently with below options
+    const domObserver = new originals.MO((domChanges, observer) => {
+      if (oncePerFrame) return;
+      oncePerFrame = true;
+      requestAnimationFrame(() => {
+        // waiting for next frame to time when any visuals are supposedly updated
+        handle('newDom', [now()], undefined, this.featureName, this.ee);
+        oncePerFrame = false;
+      });
+    });
+    const processUserInteraction = debounce(event => {
+      handle('newUIEvent', [event], undefined, this.featureName, this.ee);
+      domObserver.observe(document.body, {
+        attributes: true,
+        childList: true,
+        subtree: true,
+        characterData: true
+      });
+    }, UI_WAIT_INTERVAL, {
+      leading: true
+    });
+    eventsEE.on('fn-start', _ref => {
+      let [evt] = _ref;
+      // 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({
+      domObserver
+    });
+    function abort() {
+      this.removeOnAbort?.abort();
+      domObserver.disconnect();
+      this.abortHandler = undefined; // weakly allow this abort op to run only once
+    }
+  }
+}

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

@@ -647,7 +647,7 @@ export class Aggregate extends AggregateBase {
     }
     function saveInteraction(interaction) {
       if (interaction.ignored || !interaction.save && !interaction.routeChange) {
-        baseEE.emit('interactionDiscarded', [interaction]);
+        baseEE.emit('interactionDone', [interaction, false]);
         return;
       }
       if (state.prevInteraction === interaction) {
@@ -663,10 +663,10 @@ export class Aggregate extends AggregateBase {
         interaction.root.attrs.firstPaint = firstPaint.current.value;
         interaction.root.attrs.firstContentfulPaint = firstContentfulPaint.current.value;
       }
-      baseEE.emit('interactionSaved', [interaction]);
+      baseEE.emit('interactionDone', [interaction, true]);
       state.interactionsToHarvest.push(interaction);
-      let smCategory = 'RouteChange';
-      if (interaction.root?.attrs?.trigger === 'initialPageLoad') smCategory = 'InitialPageLoad';else if (interaction.root?.attrs?.trigger === 'api') smCategory = 'Custom';
+      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);
       scheduler.scheduleHarvest(0);
     }

package/dist/esm/features/utils/agent-session.js

@@ -5,6 +5,7 @@ import { registerHandler } from '../../common/event-emitter/register-handler';
 import { SessionEntity } from '../../common/session/session-entity';
 import { LocalStorage } from '../../common/storage/local-storage.js';
 import { FirstPartyCookies } from '../../common/storage/first-party-cookies';
+import { DEFAULT_KEY } from '../../common/session/constants';
 let ranOnce = 0;
 export function setupAgentSession(agentIdentifier) {
   const agentRuntime = getRuntime(agentIdentifier);
@@ -15,7 +16,7 @@ export function setupAgentSession(agentIdentifier) {
   const storageTypeInst = sessionInit?.domain ? new FirstPartyCookies(sessionInit.domain) : new LocalStorage();
   agentRuntime.session = new SessionEntity({
     agentIdentifier,
-    key: 'SESSION',
+    key: DEFAULT_KEY,
     storage: storageTypeInst,
     expiresMs: sessionInit?.expiresMs,
     inactiveMs: sessionInit?.inactiveMs

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

@@ -10,7 +10,8 @@ import { onWindowLoad } from '../../common/window/load';
 import { isBrowserScope } from '../../common/constants/runtime';
 import { warn } from '../../common/util/console';
 import { FEATURE_NAMES } from '../../loaders/features/features';
-import { getConfigurationValue, originals } from '../../common/config/config';
+import { getConfigurationValue } from '../../common/config/config';
+import { canImportReplayAgg, enableSessionTracking } from '../session_replay/shared/utils';
 
 /**
  * Base class for instrumenting a feature.
@@ -73,7 +74,6 @@ export class InstrumentBase extends FeatureBase {
       });
       return;
     }
-    const enableSessionTracking = isBrowserScope && getConfigurationValue(this.agentIdentifier, 'privacy.cookies_enabled') === true;
     let loadedSuccessfully;
     this.onAggregateImported = new Promise(resolve => {
       loadedSuccessfully = resolve;
@@ -81,7 +81,7 @@ export class InstrumentBase extends FeatureBase {
     const importLater = async () => {
       let session;
       try {
-        if (enableSessionTracking) {
+        if (enableSessionTracking(this.agentIdentifier)) {
           // would require some setup before certain features start
           const {
             setupAgentSession
@@ -90,6 +90,7 @@ export class InstrumentBase extends FeatureBase {
         }
       } catch (e) {
         warn('A problem occurred when starting up session manager. This page will not start or extend any session.', e);
+        if (this.featureName === FEATURE_NAMES.sessionReplay) this.abortHandler?.(); // SR should stop recording if session DNE
       }
 
       /**
@@ -97,7 +98,7 @@ export class InstrumentBase extends FeatureBase {
        * it's only responsible for aborting its one specific feature, rather than all.
        */
       try {
-        if (!this.shouldImportAgg(this.featureName, session)) {
+        if (!this.#shouldImportAgg(this.featureName, session)) {
           drain(this.agentIdentifier, this.featureName);
           loadedSuccessfully(false); // aggregate module isn't loaded at all
           return;
@@ -130,12 +131,8 @@ export class InstrumentBase extends FeatureBase {
   * @param {import('../../common/session/session-entity').SessionEntity} session
   * @returns
   */
-  shouldImportAgg(featureName, session) {
-    if (featureName === FEATURE_NAMES.sessionReplay) {
-      if (!originals.MO) return false; // Session Replay cannot work without Mutation Observer
-      if (getConfigurationValue(this.agentIdentifier, 'session_trace.enabled') === false) return false; // Session Replay as of now is tightly coupled with Session Trace in the UI
-      return !!session?.isNew || !!session?.state.sessionReplayMode; // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
-    }
+  #shouldImportAgg(featureName, session) {
+    if (featureName === FEATURE_NAMES.sessionReplay) return canImportReplayAgg(this.agentIdentifier, session);
     return true;
   }
 }

package/dist/esm/features/utils/lazy-feature-loader.js

@@ -32,6 +32,8 @@ export function lazyFeatureLoader(featureName, featurePart) {
         return import( /* webpackChunkName: "session_trace-aggregate" */'../session_trace/aggregate');
       case FEATURE_NAMES.spa:
         return import( /* webpackChunkName: "spa-aggregate" */'../spa/aggregate');
+      case FEATURE_NAMES.softNav:
+        return import( /* webpackChunkName: "basic-spa-aggregate" */'../soft_navigations/aggregate');
       default:
         throw new Error("Attempted to load unsupported agent feature: ".concat(featureName, " ").concat(featurePart));
     }

package/dist/esm/loaders/agent-base.js

@@ -1,12 +1,27 @@
 /* eslint-disable n/handle-callback-err */
 
 import { warn } from '../common/util/console';
+import { SR_EVENT_EMITTER_TYPES } from '../features/session_replay/constants';
+import { ObservationContextManager } from '../common/context/observation-context-manager';
+import { generateRandomHexString } from '../common/ids/unique-id';
+import { ee } from '../common/event-emitter/contextual-ee';
 
 /**
  * @typedef {import('./api/interaction-types').InteractionInstance} InteractionInstance
  */
 
 export class AgentBase {
+  agentIdentifier;
+  observationContext = new ObservationContextManager();
+  constructor() {
+    let agentIdentifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : generateRandomHexString(16);
+    this.agentIdentifier = agentIdentifier;
+
+    // Assign the observation context to the event emitter, so it knows how to create observation contexts
+    const eventEmitter = ee.get(agentIdentifier);
+    eventEmitter.observationContext = this.observationContext;
+  }
+
   /**
    * Tries to execute the api and generates a generic warning message with the api name injected if unsuccessful
    * @param {string} methodName
@@ -124,17 +139,17 @@ export class AgentBase {
    * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/recordReplay/}
    */
   recordReplay() {
-    return this.#callMethod('recordReplay');
+    return this.#callMethod(SR_EVENT_EMITTER_TYPES.RECORD);
   }
 
   /**
    * Forces an active replay to pause recording.  If a replay is already actively recording, this call will cause the recording to pause.
    * If a recording is not currently recording, this call will be ignored.  This API will pause both manual and automatic replays that are in progress.
    * The only way to resume recording after manually pausing a replay is to manually record again using the recordReplay() API.
-   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/recordReplay/}
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/pauseReplay/}
    */
   pauseReplay() {
-    return this.#callMethod('pauseReplay');
+    return this.#callMethod(SR_EVENT_EMITTER_TYPES.PAUSE);
   }
 
   /**

package/dist/esm/loaders/agent.js

@@ -12,8 +12,6 @@ import { Instrument as PageViewEvent } from '../features/page_view_event/instrum
 // common files
 import { Aggregator } from '../common/aggregate/aggregator';
 import { gosNREUM, setNREUMInitializedAgent } from '../common/window/nreum';
-import { generateRandomHexString } from '../common/ids/unique-id';
-import { getConfiguration, getInfo, getLoaderConfig, getRuntime } from '../common/config/config';
 import { warn } from '../common/util/console';
 import { stringify } from '../common/util/stringify';
 import { globalScope } from '../common/constants/runtime';
@@ -23,37 +21,36 @@ import { globalScope } from '../common/constants/runtime';
  * sensitive to network load, this may result in smaller builds with slightly lower performance impact.
  */
 export class Agent extends AgentBase {
-  constructor(options) {
-    let agentIdentifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : generateRandomHexString(16);
-    super();
+  constructor(options, agentIdentifier) {
+    super(agentIdentifier);
     if (!globalScope) {
       // We could not determine the runtime environment. Short-circuite the agent here
       // to avoid possible exceptions later that may cause issues with customer's application.
       warn('Failed to initial the agent. Could not determine the runtime environment.');
       return;
     }
-    this.agentIdentifier = agentIdentifier;
     this.sharedAggregator = new Aggregator({
       agentIdentifier: this.agentIdentifier
     });
     this.features = {};
-    setNREUMInitializedAgent(agentIdentifier, this); // append this agent onto the global NREUM.initializedAgents
+    setNREUMInitializedAgent(this.agentIdentifier, this); // append this agent onto the global NREUM.initializedAgents
 
     this.desiredFeatures = new Set(options.features || []); // expected to be a list of static Instrument/InstrumentBase classes, see "spa.js" for example
     // For Now... ALL agents must make the rum call whether the page_view_event feature was enabled or not.
     // NR1 creates an index on the rum call, and if not seen for a few days, will remove the browser app!
     // Future work is being planned to evaluate removing this behavior from the backend, but for now we must ensure this call is made
     this.desiredFeatures.add(PageViewEvent);
+    this.runSoftNavOverSpa = [...this.desiredFeatures].some(instr => instr.featureName === FEATURE_NAMES.softNav);
     configure(this, options, options.loaderType || 'agent'); // add api, exposed, and other config properties
 
     this.run();
   }
   get config() {
     return {
-      info: getInfo(this.agentIdentifier),
-      init: getConfiguration(this.agentIdentifier),
-      loader_config: getLoaderConfig(this.agentIdentifier),
-      runtime: getRuntime(this.agentIdentifier)
+      info: this.info,
+      init: this.init,
+      loader_config: this.loader_config,
+      runtime: this.runtime
     };
   }
   run() {
@@ -63,13 +60,13 @@ export class Agent extends AgentBase {
       const featuresToStart = [...this.desiredFeatures];
       featuresToStart.sort((a, b) => featurePriority[a.featureName] - featurePriority[b.featureName]);
       featuresToStart.forEach(InstrumentCtor => {
-        // pageViewEvent must be enabled because RUM calls are not optional. See comment in constructor and PR 428.
-        if (enabledFeatures[InstrumentCtor.featureName] || InstrumentCtor.featureName === FEATURE_NAMES.pageViewEvent) {
-          const dependencies = getFeatureDependencyNames(InstrumentCtor.featureName);
-          const hasAllDeps = dependencies.every(x => enabledFeatures[x]);
-          if (!hasAllDeps) warn("".concat(InstrumentCtor.featureName, " is enabled but one or more dependent features has been disabled (").concat(stringify(dependencies), "). This may cause unintended consequences or missing data..."));
-          this.features[InstrumentCtor.featureName] = new InstrumentCtor(this.agentIdentifier, this.sharedAggregator);
-        }
+        if (!enabledFeatures[InstrumentCtor.featureName] && InstrumentCtor.featureName !== FEATURE_NAMES.pageViewEvent) return; // PVE is required to run even if it's marked disabled
+        if (this.runSoftNavOverSpa && InstrumentCtor.featureName === FEATURE_NAMES.spa) return;
+        if (!this.runSoftNavOverSpa && InstrumentCtor.featureName === FEATURE_NAMES.softNav) return;
+        const dependencies = getFeatureDependencyNames(InstrumentCtor.featureName);
+        const hasAllDeps = dependencies.every(featName => featName in this.features); // any other feature(s) this depends on should've been initialized on prior iterations by priority order
+        if (!hasAllDeps) warn("".concat(InstrumentCtor.featureName, " is enabled but one or more dependent features has not been initialized (").concat(stringify(dependencies), "). This may cause unintended consequences or missing data..."));
+        this.features[InstrumentCtor.featureName] = new InstrumentCtor(this.agentIdentifier, this.sharedAggregator);
       });
     } catch (err) {
       warn('Failed to initialize all enabled instrument classes (agent aborted) -', err);

package/dist/esm/loaders/api/api-methods.js

@@ -1,2 +1,3 @@
-export const apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', 'recordReplay', 'pauseReplay'];
+import { SR_EVENT_EMITTER_TYPES } from '../../features/session_replay/constants';
+export const apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', 'recordReplay', 'pauseReplay', SR_EVENT_EMITTER_TYPES.RECORD, SR_EVENT_EMITTER_TYPES.PAUSE];
 export const asyncApiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease'];

package/dist/esm/loaders/api/api.js

@@ -14,6 +14,7 @@ import { warn } from '../../common/util/console';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants';
 import { gosCDN } from '../../common/window/nreum';
 import { apiMethods, asyncApiMethods } from './api-methods';
+import { SR_EVENT_EMITTER_TYPES } from '../../features/session_replay/constants';
 export function setTopLevelCallers() {
   const nr = gosCDN();
   apiMethods.forEach(f => {
@@ -38,6 +39,7 @@ export function setTopLevelCallers() {
   }
 }
 export function setAPI(agentIdentifier, forceDrain) {
+  let runSoftNavOverSpa = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   if (!forceDrain) registerDrain(agentIdentifier, 'api');
   const apiInterface = {};
   var instanceEE = ee.get(agentIdentifier);
@@ -50,7 +52,6 @@ export function setAPI(agentIdentifier, forceDrain) {
     apiInterface[fnName] = apiCall(prefix, fnName, true, 'api');
   });
   apiInterface.addPageAction = apiCall(prefix, 'addPageAction', true, FEATURE_NAMES.pageAction);
-  apiInterface.setCurrentRouteName = apiCall(prefix, 'routeName', true, FEATURE_NAMES.spa);
   apiInterface.setPageViewName = function (name, host) {
     if (typeof name !== 'string') return;
     if (name.charAt(0) !== '/') name = '/' + name;
@@ -135,25 +136,26 @@ export function setAPI(agentIdentifier, forceDrain) {
       warn('An unexpected issue occurred', err);
     }
   };
-  apiInterface.recordReplay = function () {
+  apiInterface[SR_EVENT_EMITTER_TYPES.RECORD] = function () {
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/recordReplay/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-    handle('recordReplay', [], undefined, FEATURE_NAMES.sessionReplay, instanceEE);
+    handle(SR_EVENT_EMITTER_TYPES.RECORD, [], undefined, FEATURE_NAMES.sessionReplay, instanceEE);
   };
-  apiInterface.pauseReplay = function () {
+  apiInterface[SR_EVENT_EMITTER_TYPES.PAUSE] = function () {
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/pauseReplay/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-    handle('pauseReplay', [], undefined, FEATURE_NAMES.sessionReplay, instanceEE);
+    handle(SR_EVENT_EMITTER_TYPES.PAUSE, [], undefined, FEATURE_NAMES.sessionReplay, instanceEE);
   };
-  apiInterface.interaction = function () {
-    return new InteractionHandle().get();
+  apiInterface.interaction = function (options) {
+    return new InteractionHandle().get(typeof options === 'object' ? options : {});
   };
   function InteractionHandle() {}
-  var InteractionApiProto = InteractionHandle.prototype = {
+  const InteractionApiProto = InteractionHandle.prototype = {
     createTracer: function (name, cb) {
       var contextStore = {};
       var ixn = this;
       var hasCb = typeof cb === 'function';
       handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/createTracer/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-      handle(spaPrefix + 'tracer', [now(), name, contextStore], ixn, FEATURE_NAMES.spa, instanceEE);
+      // Soft navigations won't support Tracer nodes, but this fn should still work the same otherwise (e.g., run the orig cb).
+      if (!runSoftNavOverSpa) handle(spaPrefix + 'tracer', [now(), name, contextStore], ixn, FEATURE_NAMES.spa, instanceEE);
       return function () {
         tracerEE.emit((hasCb ? '' : 'no-') + 'fn-start', [now(), ixn, hasCb], contextStore);
         if (hasCb) {
@@ -171,13 +173,14 @@ export function setAPI(agentIdentifier, forceDrain) {
     }
   };
   ['actionText', 'setName', 'setAttribute', 'save', 'ignore', 'onEnd', 'getContext', 'end', 'get'].forEach(name => {
-    InteractionApiProto[name] = apiCall(spaPrefix, name, undefined, FEATURE_NAMES.spa);
+    InteractionApiProto[name] = apiCall(spaPrefix, name, undefined, runSoftNavOverSpa ? FEATURE_NAMES.softNav : FEATURE_NAMES.spa);
   });
+  apiInterface.setCurrentRouteName = runSoftNavOverSpa ? apiCall(spaPrefix, 'routeName', undefined, FEATURE_NAMES.softNav) : apiCall(prefix, 'routeName', true, FEATURE_NAMES.spa);
   function apiCall(prefix, name, notSpa, bufferGroup) {
     return function () {
       handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/' + name + '/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
       if (bufferGroup) handle(prefix + name, [now(), ...arguments], notSpa ? null : this, bufferGroup, instanceEE); // no bufferGroup means only the SM is emitted
-      return notSpa ? undefined : this;
+      return notSpa ? undefined : this; // returns the InteractionHandle which allows these methods to be chained
     };
   }
   apiInterface.noticeError = function (err, customAttributes) {

package/dist/esm/loaders/configure/configure.js

@@ -49,10 +49,13 @@ export function configure(agent) {
     if (updatedInit.proxy.beacon) internalTrafficList.push(updatedInit.proxy.beacon);
     setTopLevelCallers(); // no need to set global APIs on newrelic obj more than once
     addToNREUM('activatedFeatures', activatedFeatures);
+
+    // Update if soft_navigations is allowed to run AND part of this agent build, used to override old spa functions.
+    agent.runSoftNavOverSpa &&= updatedInit.soft_navigations.enabled === true && updatedInit.feature_flags.includes('soft_nav');
   }
   runtime.denyList = [...(updatedInit.ajax.deny_list || []), ...(updatedInit.ajax.block_internal ? internalTrafficList : [])];
   setRuntime(agent.agentIdentifier, runtime);
-  if (agent.api === undefined) agent.api = setAPI(agent.agentIdentifier, forceDrain);
+  if (agent.api === undefined) agent.api = setAPI(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa);
   if (agent.exposed === undefined) agent.exposed = exposed;
   alreadySetOnce = true;
 }

package/dist/esm/loaders/features/enabled-features.js

@@ -2,7 +2,7 @@ import { FEATURE_NAMES } from './features';
 import { getConfigurationValue } from '../../common/config/config';
 const featureNames = Object.values(FEATURE_NAMES);
 function isEnabled(name, agentIdentifier) {
-  return getConfigurationValue(agentIdentifier, "".concat(name, ".enabled")) !== false;
+  return getConfigurationValue(agentIdentifier, "".concat(name, ".enabled")) === true;
 }
 export function getEnabledFeatures(agentIdentifier) {
   const enabledFeatures = {};

package/dist/esm/loaders/features/features.js

@@ -7,6 +7,7 @@ export const FEATURE_NAMES = {
   pageViewTiming: 'page_view_timing',
   sessionReplay: 'session_replay',
   sessionTrace: 'session_trace',
+  softNav: 'soft_navigations',
   spa: 'spa'
 };
 
@@ -23,5 +24,6 @@ export const featurePriority = {
   [FEATURE_NAMES.sessionTrace]: 6,
   [FEATURE_NAMES.pageAction]: 7,
   [FEATURE_NAMES.spa]: 8,
-  [FEATURE_NAMES.sessionReplay]: 9
+  [FEATURE_NAMES.softNav]: 9,
+  [FEATURE_NAMES.sessionReplay]: 10
 };

package/dist/types/common/aggregate/aggregator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregator.d.ts","sourceRoot":"","sources":["../../../../src/common/aggregate/aggregator.js"],"names":[],"mappings":"AAQA;IAGI,mBAAwB;IAO1B,kFAIC;IAED,gFA0BC;IAED,gEAIC;IAED,qEAUC;IAED,+BAKC;IAGD,4BAWC;CACF;8BArF6B,2BAA2B"}
+{"version":3,"file":"aggregator.d.ts","sourceRoot":"","sources":["../../../../src/common/aggregate/aggregator.js"],"names":[],"mappings":"AAQA;IAGI,mBAAwB;IAO1B,kFAIC;IAED,gFA0BC;IAED,gEAIC;IAED,qEAUC;IAED,+BAKC;IAGD,4BAYC;CACF;8BAtF6B,2BAA2B"}

package/dist/types/common/config/state/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/init.js"],"names":[],"mappings":"AA6GA,+CAIC;AAED,0DAKC;AAED,+DAYC"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../src/common/config/state/init.js"],"names":[],"mappings":"AA+GA,+CAIC;AAED,0DAKC;AAED,+DAYC"}

package/dist/types/common/context/event-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-context.d.ts","sourceRoot":"","sources":["../../../../src/common/context/event-context.js"],"names":[],"mappings":"AAAA;IACE,4BAEC;IADC,eAA0B;CAE7B"}

package/dist/types/common/context/observation-context-manager.d.ts

@@ -0,0 +1,28 @@
+export class ObservationContextManager {
+    static contextId: string;
+    static contextOriginalId: string;
+    static contextWrappedId: string;
+    static getObservationContextByAgentIdentifier(agentIdentifier: any): any;
+    /**
+     * Returns the observation context tied to the supplied construct. If there has been
+     * no observation construct created, an empty object is created and stored as the current
+     * context.
+     * @param key {unknown} The construct being observed such as an XHR instance
+     * @return {EventContext} An object of key:value pairs to track as
+     * part of the observation
+     */
+    getCreateContext(key: unknown): EventContext;
+    /**
+     * Set the observation context for an observed construct. If values of the context
+     * need to be updated, they should be done so directly on the context. This function
+     * is only for the setting of a whole context.
+     * @param key {unknown} The construct being observed such as an XHR instance
+     * @param value {EventContext} An object of key:value pairs to track as
+     * part of the observation
+     * @return {EventContext} The updated observation context
+     */
+    setContext(key: unknown, value: EventContext): EventContext;
+    #private;
+}
+import { EventContext } from './event-context';
+//# sourceMappingURL=observation-context-manager.d.ts.map

package/dist/types/common/context/observation-context-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation-context-manager.d.ts","sourceRoot":"","sources":["../../../../src/common/context/observation-context-manager.js"],"names":[],"mappings":"AAIA;IAIE,yBAA2C;IAC3C,iCAAoD;IACpD,gCAA6E;IAE7E,yEAKC;IAOD;;;;;;;OAOG;IACH,sBAJe,OAAO,GACV,YAAY,CASvB;IAED;;;;;;;;OAQG;IACH,gBALe,OAAO,SACL,YAAY,GAEjB,YAAY,CAMvB;;CACF;6BApD4B,iBAAiB"}

package/dist/types/common/event-emitter/contextual-ee.d.ts

@@ -1,3 +1,4 @@
+export { globalInstance as ee };
 declare namespace globalInstance {
     export { addEventListener as on };
     export { addEventListener };
@@ -12,13 +13,12 @@ declare namespace globalInstance {
     export { isBuffering };
     export { debugId };
     export let backlog: any;
+    export let observationContextManager: null;
 }
-export const contextId: string;
 declare function emit(type: any, args: any, contextOrStore: any, force: any, bubble: any): any;
 declare function getOrCreate(name: any): any;
 declare function listeners(type: any): any;
 declare function bufferEventsByGroup(types: any, group: any): void;
 declare function abort(): void;
 declare function isBuffering(type: any): boolean;
-export { globalInstance as ee };
 //# sourceMappingURL=contextual-ee.d.ts.map

package/dist/types/common/event-emitter/contextual-ee.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextual-ee.d.ts","sourceRoot":"","sources":["../../../../src/common/event-emitter/contextual-ee.js"],"names":[],"mappings":";;;;;;;;;;;;;;;AAYA,+BAA0C;AA0DxC,+FAsBC;AAqBD,6CAEC;AAND,2CAEC;AAMD,mEAaC;AAcH,+BASC;AArBC,iDAGC"}
+{"version":3,"file":"contextual-ee.d.ts","sourceRoot":"","sources":["../../../../src/common/event-emitter/contextual-ee.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AA0EE,+FAsBC;AAqBD,6CAQC;AAZD,2CAEC;AAYD,mEAaC;AAcH,+BASC;AArBC,iDAGC"}

package/dist/types/common/session/constants.d.ts

@@ -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 namespace SESSION_EVENTS {

package/dist/types/common/session/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/common/session/constants.js"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,0CAA0C;AAC1C,0CAA0C"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/common/session/constants.js"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,oCAAoC;AACpC,0CAA0C;AAC1C,0CAA0C"}

package/dist/types/common/timing/nav-timing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nav-timing.d.ts","sourceRoot":"","sources":["../../../../src/common/timing/nav-timing.js"],"names":[],"mappings":"AAwCA,uFAyBC;AAGD,4CAIC;AA7CD,oCAA+B"}
+{"version":3,"file":"nav-timing.d.ts","sourceRoot":"","sources":["../../../../src/common/timing/nav-timing.js"],"names":[],"mappings":"AAwCA,uFAyBC;AAGD,4CAIC;AA7CD,oCAAiC"}

package/dist/types/common/wrap/index.d.ts

@@ -4,8 +4,7 @@ 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 };
 //# sourceMappingURL=index.d.ts.map

package/dist/types/common/wrap/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/index.js"],"names":[],"mappings":"2BAI2B,eAAe;0BAChB,cAAc;4BACZ,gBAAgB;0BAClB,cAAc;6BACX,iBAAiB;4BAClB,gBAAgB;wBACpB,YAAY;0BACV,cAAc;wBAChB,YAAY"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/index.js"],"names":[],"mappings":"2BAI2B,eAAe;0BAChB,cAAc;4BACZ,gBAAgB;0BAClB,cAAc;6BACX,iBAAiB;4BAClB,gBAAgB;0BAClB,cAAc;wBAChB,YAAY"}

package/dist/types/common/wrap/wrap-fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-fetch.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-fetch.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,oCAJW,MAAM,GAEJ,MAAM,CAqElB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,GAEJ,MAAM,CAIlB"}
+{"version":3,"file":"wrap-fetch.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-fetch.js"],"names":[],"mappings":"AAqBA;;;;;;;GAOG;AACH,oCAJW,MAAM,GAEJ,MAAM,CAqElB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,GAEJ,MAAM,CAIlB"}

package/dist/types/common/wrap/wrap-function.d.ts

@@ -5,6 +5,5 @@
  * @returns {function} The wrapped function.
  */
 export function createWrapperWithEmitter(emitter?: Object | undefined, always: boolean): Function;
-export const flag: string;
 export default createWrapperWithEmitter;
 //# sourceMappingURL=wrap-function.d.ts.map

package/dist/types/common/wrap/wrap-function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-function.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-function.js"],"names":[],"mappings":"AA4BA;;;;;GAKG;AACH,+EAHW,OAAO,YAgIjB;AApJD,0BAA6C"}
+{"version":3,"file":"wrap-function.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-function.js"],"names":[],"mappings":"AA0BA;;;;;GAKG;AACH,+EAHW,OAAO,YAgIjB"}

package/dist/types/common/wrap/wrap-promise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-promise.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-promise.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,sCAHW,MAAM,GACJ,MAAM,CAqIlB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,GAEJ,MAAM,CAIlB"}
+{"version":3,"file":"wrap-promise.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-promise.js"],"names":[],"mappings":"AAgBA;;;;;;GAMG;AACH,sCAHW,MAAM,GACJ,MAAM,CAqIlB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,GAEJ,MAAM,CAIlB"}

package/dist/types/features/ajax/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/ajax/aggregate/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IACjC,mDAyOC;IAlNC,qGAAwB;IACxB;;;;4BAAoC;IACpC;;;mBAA2E;CAiN9E;8BA/O6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/ajax/aggregate/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAAiC;IACjC,mDA0PC;IAnOC,qGAAwB;IACxB;;;;4BAAoC;IACpC;;;mBAA2E;CAkO9E;8BAjQ6B,4BAA4B"}

package/dist/types/features/jserrors/aggregate/index.d.ts

@@ -7,7 +7,7 @@ export class Aggregate extends AggregateBase {
     stackReported: {};
     observedAt: {};
     pageviewReported: {};
-    errorCache: {};
+    bufferedErrorsUnderSpa: {};
     currentBody: {} | null | undefined;
     errorOnPage: boolean;
     onHarvestStarted(options: any): {
@@ -26,8 +26,9 @@ export class Aggregate extends AggregateBase {
      */
     buildCanonicalStackString(stackInfo: StackInfo): string;
     storeError(err: any, time: any, internal: any, customAttributes: any): void;
-    onInteractionSaved(interaction: any): void;
-    onInteractionDiscarded(interaction: any): void;
+    onInteractionDone(interaction: any, wasSaved: any): void;
+    onSoftNavNotification(interactionId: any, wasFinished: any, softNavAttrs: any): void;
+    #private;
 }
 export type StackInfo = import('./compute-stack-trace.js').StackInfo;
 import { AggregateBase } from '../../utils/aggregate-base';

package/dist/types/features/jserrors/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAuBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAoCC;IAjCC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,eAAoB;IACpB,mCAA4B;IAC5B,qBAAwB;IA8B1B;;;MAoBC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4EA4FC;IAED,2CAgCC;IAED,+CA2BC;CACF;wBA7QY,OAAO,0BAA0B,EAAE,SAAS;8BAH3B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAwBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAmCC;IAhCC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,mCAA4B;IAC5B,qBAAwB;IA6B1B;;;MAoBC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4EAsFC;IA4BD,yDA6BC;IAED,qFAOC;;CACF;wBAzQY,OAAO,0BAA0B,EAAE,SAAS;8BAJ3B,4BAA4B"}

package/dist/types/features/page_view_event/aggregate/initialized-features.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialized-features.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate/initialized-features.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,4DAFa,QAAQ,CAwBpB"}
+{"version":3,"file":"initialized-features.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate/initialized-features.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,4DAFa,QAAQ,CAyBpB"}

package/dist/types/features/session_replay/aggregate/index.d.ts

@@ -13,7 +13,7 @@ export class Aggregate extends AggregateBase {
     /** set by BCS response */
     entitled: boolean;
     recorder: any;
-    scheduler: HarvestScheduler | undefined;
+    scheduler: HarvestScheduler;
     errorNoticed: boolean;
     switchToFull(): void;
     /**