@newrelic/browser-agent 1.252.0 → 1.253.0

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

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Instrument = void 0;
+var _config = require("../../../common/config/config");
+var _runtime = require("../../../common/constants/runtime");
+var _handle = require("../../../common/event-emitter/handle");
+var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
+var _now = require("../../../common/timing/now");
+var _invoke = require("../../../common/util/invoke");
+var _wrap = require("../../../common/wrap");
+var _instrumentBase = require("../../utils/instrument-base");
+var _constants = require("../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
+
+class Instrument extends _instrumentBase.InstrumentBase {
+  static featureName = _constants.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    super(agentIdentifier, aggregator, _constants.FEATURE_NAME, auto);
+    if (!_runtime.isBrowserScope || !_config.originals.MO) return; // soft navigations is not supported outside web env or browsers without the mutation observer API
+
+    const historyEE = (0, _wrap.wrapHistory)(this.ee);
+    const eventsEE = (0, _wrap.wrapEvents)(this.ee);
+    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);
+    try {
+      this.removeOnAbort = new AbortController();
+    } catch (e) {}
+    const trackURLChangeEvent = evt => (0, _handle.handle)('newURL', [evt.timeStamp, '' + window.location], undefined, this.featureName, this.ee);
+    (0, _eventListenerOpts.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 _config.originals.MO((domChanges, observer) => {
+      if (oncePerFrame) return;
+      oncePerFrame = true;
+      requestAnimationFrame(() => {
+        // waiting for next frame to time when any visuals are supposedly updated
+        (0, _handle.handle)('newDom', [(0, _now.now)()], undefined, this.featureName, this.ee);
+        oncePerFrame = false;
+      });
+    });
+    const processUserInteraction = (0, _invoke.debounce)(event => {
+      (0, _handle.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 (_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({
+      domObserver
+    });
+    function abort() {
+      this.removeOnAbort?.abort();
+      domObserver.disconnect();
+      this.abortHandler = undefined; // weakly allow this abort op to run only once
+    }
+  }
+}
+exports.Instrument = Instrument;

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

@@ -656,7 +656,7 @@ class Aggregate extends _aggregateBase.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) {
@@ -672,10 +672,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
         interaction.root.attrs.firstPaint = _firstPaint.firstPaint.current.value;
         interaction.root.attrs.firstContentfulPaint = _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';
       (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);
       scheduler.scheduleHarvest(0);
     }

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

@@ -11,6 +11,7 @@ var _registerHandler = require("../../common/event-emitter/register-handler");
 var _sessionEntity = require("../../common/session/session-entity");
 var _localStorage = require("../../common/storage/local-storage.js");
 var _firstPartyCookies = require("../../common/storage/first-party-cookies");
+var _constants = require("../../common/session/constants");
 let ranOnce = 0;
 function setupAgentSession(agentIdentifier) {
   const agentRuntime = (0, _config.getRuntime)(agentIdentifier);
@@ -21,7 +22,7 @@ function setupAgentSession(agentIdentifier) {
   const storageTypeInst = sessionInit?.domain ? new _firstPartyCookies.FirstPartyCookies(sessionInit.domain) : new _localStorage.LocalStorage();
   agentRuntime.session = new _sessionEntity.SessionEntity({
     agentIdentifier,
-    key: 'SESSION',
+    key: _constants.DEFAULT_KEY,
     storage: storageTypeInst,
     expiresMs: sessionInit?.expiresMs,
     inactiveMs: sessionInit?.inactiveMs

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

@@ -11,6 +11,7 @@ var _runtime = require("../../common/constants/runtime");
 var _console = require("../../common/util/console");
 var _features = require("../../loaders/features/features");
 var _config = require("../../common/config/config");
+var _utils = require("../session_replay/shared/utils");
 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 && Object.prototype.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; } /**
  * @file Defines `InstrumentBase` to be used as the super of the Instrument classes implemented by each feature.
@@ -78,7 +79,6 @@ class InstrumentBase extends _featureBase.FeatureBase {
       });
       return;
     }
-    const enableSessionTracking = _runtime.isBrowserScope && (0, _config.getConfigurationValue)(this.agentIdentifier, 'privacy.cookies_enabled') === true;
     let loadedSuccessfully;
     this.onAggregateImported = new Promise(resolve => {
       loadedSuccessfully = resolve;
@@ -86,7 +86,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
     const importLater = async () => {
       let session;
       try {
-        if (enableSessionTracking) {
+        if ((0, _utils.enableSessionTracking)(this.agentIdentifier)) {
           // would require some setup before certain features start
           const {
             setupAgentSession
@@ -95,6 +95,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
         }
       } catch (e) {
         (0, _console.warn)('A problem occurred when starting up session manager. This page will not start or extend any session.', e);
+        if (this.featureName === _features.FEATURE_NAMES.sessionReplay) this.abortHandler?.(); // SR should stop recording if session DNE
       }
 
       /**
@@ -102,7 +103,7 @@ class InstrumentBase extends _featureBase.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)) {
           (0, _drain.drain)(this.agentIdentifier, this.featureName);
           loadedSuccessfully(false); // aggregate module isn't loaded at all
           return;
@@ -135,12 +136,8 @@ class InstrumentBase extends _featureBase.FeatureBase {
   * @param {import('../../common/session/session-entity').SessionEntity} session
   * @returns
   */
-  shouldImportAgg(featureName, session) {
-    if (featureName === _features.FEATURE_NAMES.sessionReplay) {
-      if (!_config.originals.MO) return false; // Session Replay cannot work without Mutation Observer
-      if ((0, _config.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 === _features.FEATURE_NAMES.sessionReplay) return (0, _utils.canImportReplayAgg)(this.agentIdentifier, session);
     return true;
   }
 }

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

@@ -39,6 +39,8 @@ function lazyFeatureLoader(featureName, featurePart) {
         return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "session_trace-aggregate" */'../session_trace/aggregate')));
       case _features.FEATURE_NAMES.spa:
         return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "spa-aggregate" */'../spa/aggregate')));
+      case _features.FEATURE_NAMES.softNav:
+        return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "basic-spa-aggregate" */'../soft_navigations/aggregate')));
       default:
         throw new Error("Attempted to load unsupported agent feature: ".concat(featureName, " ").concat(featurePart));
     }

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

@@ -5,6 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.AgentBase = void 0;
 var _console = require("../common/util/console");
+var _constants = require("../features/session_replay/constants");
+var _observationContextManager = require("../common/context/observation-context-manager");
+var _uniqueId = require("../common/ids/unique-id");
+var _contextualEe = require("../common/event-emitter/contextual-ee");
 /* eslint-disable n/handle-callback-err */
 
 /**
@@ -12,6 +16,17 @@ var _console = require("../common/util/console");
  */
 
 class AgentBase {
+  agentIdentifier;
+  observationContext = new _observationContextManager.ObservationContextManager();
+  constructor() {
+    let agentIdentifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (0, _uniqueId.generateRandomHexString)(16);
+    this.agentIdentifier = agentIdentifier;
+
+    // Assign the observation context to the event emitter, so it knows how to create observation contexts
+    const eventEmitter = _contextualEe.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
@@ -129,17 +144,17 @@ class AgentBase {
    * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/recordReplay/}
    */
   recordReplay() {
-    return this.#callMethod('recordReplay');
+    return this.#callMethod(_constants.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(_constants.SR_EVENT_EMITTER_TYPES.PAUSE);
   }
 
   /**

package/dist/cjs/loaders/agent.js

@@ -14,8 +14,6 @@ var _features = require("./features/features");
 var _instrument = require("../features/page_view_event/instrument");
 var _aggregator = require("../common/aggregate/aggregator");
 var _nreum = require("../common/window/nreum");
-var _uniqueId = require("../common/ids/unique-id");
-var _config = require("../common/config/config");
 var _console = require("../common/util/console");
 var _stringify = require("../common/util/stringify");
 var _runtime = require("../common/constants/runtime");
@@ -32,37 +30,36 @@ var _runtime = require("../common/constants/runtime");
  * sensitive to network load, this may result in smaller builds with slightly lower performance impact.
  */
 class Agent extends _agentBase.AgentBase {
-  constructor(options) {
-    let agentIdentifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (0, _uniqueId.generateRandomHexString)(16);
-    super();
+  constructor(options, agentIdentifier) {
+    super(agentIdentifier);
     if (!_runtime.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.
       (0, _console.warn)('Failed to initial the agent. Could not determine the runtime environment.');
       return;
     }
-    this.agentIdentifier = agentIdentifier;
     this.sharedAggregator = new _aggregator.Aggregator({
       agentIdentifier: this.agentIdentifier
     });
     this.features = {};
-    (0, _nreum.setNREUMInitializedAgent)(agentIdentifier, this); // append this agent onto the global NREUM.initializedAgents
+    (0, _nreum.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(_instrument.Instrument);
+    this.runSoftNavOverSpa = [...this.desiredFeatures].some(instr => instr.featureName === _features.FEATURE_NAMES.softNav);
     (0, _configure.configure)(this, options, options.loaderType || 'agent'); // add api, exposed, and other config properties
 
     this.run();
   }
   get config() {
     return {
-      info: (0, _config.getInfo)(this.agentIdentifier),
-      init: (0, _config.getConfiguration)(this.agentIdentifier),
-      loader_config: (0, _config.getLoaderConfig)(this.agentIdentifier),
-      runtime: (0, _config.getRuntime)(this.agentIdentifier)
+      info: this.info,
+      init: this.init,
+      loader_config: this.loader_config,
+      runtime: this.runtime
     };
   }
   run() {
@@ -72,13 +69,13 @@ class Agent extends _agentBase.AgentBase {
       const featuresToStart = [...this.desiredFeatures];
       featuresToStart.sort((a, b) => _features.featurePriority[a.featureName] - _features.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 === _features.FEATURE_NAMES.pageViewEvent) {
-          const dependencies = (0, _featureDependencies.getFeatureDependencyNames)(InstrumentCtor.featureName);
-          const hasAllDeps = dependencies.every(x => enabledFeatures[x]);
-          if (!hasAllDeps) (0, _console.warn)("".concat(InstrumentCtor.featureName, " is enabled but one or more dependent features has been disabled (").concat((0, _stringify.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 !== _features.FEATURE_NAMES.pageViewEvent) return; // PVE is required to run even if it's marked disabled
+        if (this.runSoftNavOverSpa && InstrumentCtor.featureName === _features.FEATURE_NAMES.spa) return;
+        if (!this.runSoftNavOverSpa && InstrumentCtor.featureName === _features.FEATURE_NAMES.softNav) return;
+        const dependencies = (0, _featureDependencies.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) (0, _console.warn)("".concat(InstrumentCtor.featureName, " is enabled but one or more dependent features has not been initialized (").concat((0, _stringify.stringify)(dependencies), "). This may cause unintended consequences or missing data..."));
+        this.features[InstrumentCtor.featureName] = new InstrumentCtor(this.agentIdentifier, this.sharedAggregator);
       });
     } catch (err) {
       (0, _console.warn)('Failed to initialize all enabled instrument classes (agent aborted) -', err);

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

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asyncApiMethods = exports.apiMethods = void 0;
+var _constants = require("../../features/session_replay/constants");
+const apiMethods = exports.apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', 'recordReplay', 'pauseReplay', _constants.SR_EVENT_EMITTER_TYPES.RECORD, _constants.SR_EVENT_EMITTER_TYPES.PAUSE];
+const asyncApiMethods = exports.asyncApiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease'];

package/dist/cjs/loaders/api/api.js

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.CUSTOM_ATTR_GROUP = void 0;
 exports.setAPI = setAPI;
 exports.setTopLevelCallers = setTopLevelCallers;
 var _features = require("../features/features");
@@ -17,17 +16,16 @@ var _runtime = require("../../common/constants/runtime");
 var _console = require("../../common/util/console");
 var _constants = require("../../features/metrics/constants");
 var _nreum = require("../../common/window/nreum");
+var _apiMethods = require("./api-methods");
+var _constants2 = require("../../features/session_replay/constants");
 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 && Object.prototype.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; } /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-const CUSTOM_ATTR_GROUP = exports.CUSTOM_ATTR_GROUP = 'CUSTOM/'; // the subgroup items should be stored under in storage API
-
 function setTopLevelCallers() {
   const nr = (0, _nreum.gosCDN)();
-  const funcs = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', 'recordReplay', 'pauseReplay'];
-  funcs.forEach(f => {
+  _apiMethods.apiMethods.forEach(f => {
     nr[f] = function () {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
@@ -49,20 +47,19 @@ function setTopLevelCallers() {
   }
 }
 function setAPI(agentIdentifier, forceDrain) {
+  let runSoftNavOverSpa = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   if (!forceDrain) (0, _drain.registerDrain)(agentIdentifier, 'api');
   const apiInterface = {};
   var instanceEE = _contextualEe.ee.get(agentIdentifier);
   var tracerEE = instanceEE.get('tracer');
-  var asyncApiFns = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease'];
   var prefix = 'api-';
   var spaPrefix = prefix + 'ixn-';
 
   // Setup stub functions that queue calls for later processing.
-  asyncApiFns.forEach(fnName => {
+  _apiMethods.asyncApiMethods.forEach(fnName => {
     apiInterface[fnName] = apiCall(prefix, fnName, true, 'api');
   });
   apiInterface.addPageAction = apiCall(prefix, 'addPageAction', true, _features.FEATURE_NAMES.pageAction);
-  apiInterface.setCurrentRouteName = apiCall(prefix, 'routeName', true, _features.FEATURE_NAMES.spa);
   apiInterface.setPageViewName = function (name, host) {
     if (typeof name !== 'string') return;
     if (name.charAt(0) !== '/') name = '/' + name;
@@ -147,25 +144,26 @@ function setAPI(agentIdentifier, forceDrain) {
       (0, _console.warn)('An unexpected issue occurred', err);
     }
   };
-  apiInterface.recordReplay = function () {
+  apiInterface[_constants2.SR_EVENT_EMITTER_TYPES.RECORD] = function () {
     (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/recordReplay/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
-    (0, _handle.handle)('recordReplay', [], undefined, _features.FEATURE_NAMES.sessionReplay, instanceEE);
+    (0, _handle.handle)(_constants2.SR_EVENT_EMITTER_TYPES.RECORD, [], undefined, _features.FEATURE_NAMES.sessionReplay, instanceEE);
   };
-  apiInterface.pauseReplay = function () {
+  apiInterface[_constants2.SR_EVENT_EMITTER_TYPES.PAUSE] = function () {
     (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/pauseReplay/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
-    (0, _handle.handle)('pauseReplay', [], undefined, _features.FEATURE_NAMES.sessionReplay, instanceEE);
+    (0, _handle.handle)(_constants2.SR_EVENT_EMITTER_TYPES.PAUSE, [], undefined, _features.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';
       (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/createTracer/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
-      (0, _handle.handle)(spaPrefix + 'tracer', [(0, _now.now)(), name, contextStore], ixn, _features.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) (0, _handle.handle)(spaPrefix + 'tracer', [(0, _now.now)(), name, contextStore], ixn, _features.FEATURE_NAMES.spa, instanceEE);
       return function () {
         tracerEE.emit((hasCb ? '' : 'no-') + 'fn-start', [(0, _now.now)(), ixn, hasCb], contextStore);
         if (hasCb) {
@@ -183,13 +181,14 @@ function setAPI(agentIdentifier, forceDrain) {
     }
   };
   ['actionText', 'setName', 'setAttribute', 'save', 'ignore', 'onEnd', 'getContext', 'end', 'get'].forEach(name => {
-    InteractionApiProto[name] = apiCall(spaPrefix, name, undefined, _features.FEATURE_NAMES.spa);
+    InteractionApiProto[name] = apiCall(spaPrefix, name, undefined, runSoftNavOverSpa ? _features.FEATURE_NAMES.softNav : _features.FEATURE_NAMES.spa);
   });
+  apiInterface.setCurrentRouteName = runSoftNavOverSpa ? apiCall(spaPrefix, 'routeName', undefined, _features.FEATURE_NAMES.softNav) : apiCall(prefix, 'routeName', true, _features.FEATURE_NAMES.spa);
   function apiCall(prefix, name, notSpa, bufferGroup) {
     return function () {
       (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/' + name + '/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
       if (bufferGroup) (0, _handle.handle)(prefix + name, [(0, _now.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/cjs/loaders/configure/configure.js

@@ -9,7 +9,7 @@ var _nreum = require("../../common/window/nreum");
 var _config = require("../../common/config/config");
 var _featureFlags = require("../../common/util/feature-flags");
 var _runtime = require("../../common/constants/runtime");
-var _publicPath = require("./public-path");
+var _publicPath = require("./public-path.npm");
 let alreadySetOnce = false; // the configure() function can run multiple times in agent lifecycle
 
 /**
@@ -55,10 +55,13 @@ function configure(agent) {
     if (updatedInit.proxy.beacon) internalTrafficList.push(updatedInit.proxy.beacon);
     (0, _api.setTopLevelCallers)(); // no need to set global APIs on newrelic obj more than once
     (0, _nreum.addToNREUM)('activatedFeatures', _featureFlags.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 : [])];
   (0, _config.setRuntime)(agent.agentIdentifier, runtime);
-  if (agent.api === undefined) agent.api = (0, _api.setAPI)(agent.agentIdentifier, forceDrain);
+  if (agent.api === undefined) agent.api = (0, _api.setAPI)(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa);
   if (agent.exposed === undefined) agent.exposed = exposed;
   alreadySetOnce = true;
 }

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

@@ -8,7 +8,7 @@ var _features = require("./features");
 var _config = require("../../common/config/config");
 const featureNames = Object.values(_features.FEATURE_NAMES);
 function isEnabled(name, agentIdentifier) {
-  return (0, _config.getConfigurationValue)(agentIdentifier, "".concat(name, ".enabled")) !== false;
+  return (0, _config.getConfigurationValue)(agentIdentifier, "".concat(name, ".enabled")) === true;
 }
 function getEnabledFeatures(agentIdentifier) {
   const enabledFeatures = {};

package/dist/cjs/loaders/features/features.js

@@ -13,6 +13,7 @@ const FEATURE_NAMES = exports.FEATURE_NAMES = {
   pageViewTiming: 'page_view_timing',
   sessionReplay: 'session_replay',
   sessionTrace: 'session_trace',
+  softNav: 'soft_navigations',
   spa: 'spa'
 };
 
@@ -29,5 +30,6 @@ const featurePriority = exports.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/esm/cdn/experimental.js

@@ -16,9 +16,12 @@ import { Instrument as InstrumentErrors } from '../features/jserrors/instrument'
 import { Instrument as InstrumentXhr } from '../features/ajax/instrument';
 import { Instrument as InstrumentSessionTrace } from '../features/session_trace/instrument';
 import { Instrument as InstrumentSessionReplay } from '../features/session_replay/instrument';
-import { Instrument as InstrumentSpa } from '../features/spa/instrument';
+// import { Instrument as InstrumentSpa } from '../features/spa/instrument'
+import { Instrument as InstrumentSoftNav } from '../features/soft_navigations/instrument';
 import { Instrument as InstrumentPageAction } from '../features/page_action/instrument';
 new Agent({
-  features: [InstrumentXhr, InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentSessionReplay, InstrumentMetrics, InstrumentPageAction, InstrumentErrors, InstrumentSpa],
+  features: [InstrumentXhr, InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentSessionReplay, InstrumentMetrics, InstrumentPageAction, InstrumentErrors,
+  // InstrumentSpa,
+  InstrumentSoftNav],
   loaderType: 'experimental'
 });

package/dist/esm/cdn/spa.js

@@ -10,9 +10,11 @@ import { Instrument as InstrumentErrors } from '../features/jserrors/instrument'
 import { Instrument as InstrumentXhr } from '../features/ajax/instrument';
 import { Instrument as InstrumentSessionTrace } from '../features/session_trace/instrument';
 import { Instrument as InstrumentSessionReplay } from '../features/session_replay/instrument';
+import { Instrument as InstrumentSoftNav } from '../features/soft_navigations/instrument';
 import { Instrument as InstrumentSpa } from '../features/spa/instrument';
 import { Instrument as InstrumentPageAction } from '../features/page_action/instrument';
 new Agent({
-  features: [InstrumentXhr, InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentSessionReplay, InstrumentMetrics, InstrumentPageAction, InstrumentErrors, InstrumentSpa],
+  features: [InstrumentXhr, InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentSessionReplay, InstrumentMetrics, InstrumentPageAction, InstrumentErrors, InstrumentSoftNav, InstrumentSpa // either the softnav or the old spa will be used (not both), but we still need to pack both to avoid dynamic import for instrument files
+  ],
   loaderType: 'spa'
 });

package/dist/esm/common/aggregate/aggregator.js

@@ -77,7 +77,7 @@ export class Aggregator extends SharedContext {
     var hasData = false;
     for (var i = 0; i < types.length; i++) {
       type = types[i];
-      results[type] = toArray(this.aggregatedData[type]);
+      results[type] = Object.values(this.aggregatedData[type] || {});
       if (results[type].length) hasData = true;
       delete this.aggregatedData[type];
     }
@@ -151,11 +151,4 @@ function createMetricObject(value) {
     sos: value * value,
     c: 1
   };
-}
-function toArray(obj) {
-  if (typeof obj !== 'object') return [];
-  return mapOwn(obj, getValue);
-}
-function getValue(key, value) {
-  return value;
 }

package/dist/esm/common/config/state/init.js

@@ -98,6 +98,8 @@ const model = () => {
       autoStart: true,
       enabled: false,
       harvestTimeSeconds: 60,
+      preload: false,
+      // if true, enables the agent to load rrweb immediately instead of waiting to do so after the window.load event
       sampling_rate: 10,
       // float from 0 - 100
       error_sampling_rate: 100,
@@ -150,6 +152,11 @@ const model = () => {
       enabled: true,
       harvestTimeSeconds: 10,
       autoStart: true
+    },
+    soft_navigations: {
+      enabled: true,
+      harvestTimeSeconds: 10,
+      autoStart: true
     }
   };
 };

package/dist/esm/common/constants/env.cdn.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.252.0";
+export const VERSION = "1.253.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/constants/env.npm.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.252.0";
+export const VERSION = "1.253.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/context/observation-context-manager.js

@@ -0,0 +1,49 @@
+import { gosNREUM } from '../window/nreum';
+import { bundleId } from '../ids/bundle-id';
+import { EventContext } from './event-context';
+export class ObservationContextManager {
+  // These IDs are provided for backwards compatibility until the agent is fully updated
+  // use the observation context class.
+
+  static contextId = "nr@context:".concat(bundleId);
+  static contextOriginalId = "nr@original:".concat(bundleId);
+  static contextWrappedId = "nr@wrapped:".concat(ObservationContextManager.contextId);
+  static getObservationContextByAgentIdentifier(agentIdentifier) {
+    const nr = gosNREUM();
+    return Object.keys(nr?.initializedAgents || {}).indexOf(agentIdentifier) > -1 ? nr.initializedAgents[agentIdentifier].observationContext : undefined;
+  }
+
+  /**
+   * @type {WeakMap<WeakKey, {[key: string]: unknown}>}
+   */
+  #observationContext = new WeakMap();
+
+  /**
+   * 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) {
+    if (!this.#observationContext.has(key)) {
+      this.#observationContext.set(key, new EventContext());
+    }
+    return this.#observationContext.get(key);
+  }
+
+  /**
+   * 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, value) {
+    this.#observationContext.set(key, value);
+    return this.#observationContext.get(key);
+  }
+}