@newrelic/browser-agent 1.252.1 → 1.254.0

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/config/state/runtime.js

@@ -17,10 +17,13 @@ const model = {
   origin: '' + globalScope.location,
   ptid: undefined,
   releaseIds: {},
+  /** Agent-specific metadata found in the RUM call response. ex. entityGuid */
+  appMetadata: {},
   session: undefined,
   xhrWrappable: typeof globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
   version: VERSION,
-  denyList: undefined
+  denyList: undefined,
+  harvestCount: 0
 };
 const _cache = {};
 export function getRuntime(id) {

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.252.1";
+export const VERSION = "1.254.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.1";
+export const VERSION = "1.254.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/drain/drain.js

@@ -28,13 +28,24 @@ export function registerDrain(agentIdentifier, group) {
   if (!registry[agentIdentifier].get(group)) registry[agentIdentifier].set(group, item);
 }
 
+/**
+ * Removes an item from the registry and immediately re-checks if the registry is ready to "drain all"
+ * @param {*} agentIdentifier - A 16 character string uniquely identifying the agent.
+ * @param {*} group - The named "bucket" to be removed from the registry
+ */
+export function deregisterDrain(agentIdentifier, group) {
+  curateRegistry(agentIdentifier);
+  if (registry[agentIdentifier].get(group)) registry[agentIdentifier].delete(group);
+  if (registry[agentIdentifier].size) checkCanDrainAll(agentIdentifier);
+}
+
 /**
  * Registers the specified agent with the centralized event buffer registry if it is not already registered.
  * Agents without an identifier (as in the case of some tests) will be excluded from the registry.
  * @param {string} agentIdentifier - A 16 character string uniquely identifying an agent.
  */
 function curateRegistry(agentIdentifier) {
-  if (!agentIdentifier) return;
+  if (!agentIdentifier) throw new Error('agentIdentifier required');
   if (!registry[agentIdentifier]) registry[agentIdentifier] = new Map();
 }
 
@@ -53,11 +64,15 @@ export function drain() {
   // If the feature for the specified agent is not in the registry, that means the instrument file was bypassed.
   // This could happen in tests, or loaders that directly import the aggregator. In these cases it is safe to
   // drain the feature group immediately rather than waiting to drain all at once.
-  if (!agentIdentifier || !registry[agentIdentifier].get(featureName) || force) return drainGroup(featureName);
+  if (!agentIdentifier || !registry[agentIdentifier].get(featureName) || force) return drainGroup(agentIdentifier, featureName);
 
   // When `drain` is called, this feature is ready to drain (staged).
   registry[agentIdentifier].get(featureName).staged = true;
+  checkCanDrainAll(agentIdentifier);
+}
 
+/** Checks all items in the registry to see if they have been "staged".  If ALL items are staged, it will drain all registry items (drainGroup).  It not, nothing will happen */
+function checkCanDrainAll(agentIdentifier) {
   // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
   // that the last feature to call drain triggers drain for all features.
   const items = [...registry[agentIdentifier]];
@@ -69,40 +84,38 @@ export function drain() {
     items.forEach(_ref2 => {
       let [group] = _ref2;
       registry[agentIdentifier].delete(group);
-      drainGroup(group);
+      drainGroup(agentIdentifier, group);
     });
   }
+}
 
-  /**
+/**
    * Drains all the buffered (backlog) events for a particular feature's event-group by emitting each event to each of
    * the subscribed handlers for the group.
    * @param {*} group - The name of a particular feature's event "bucket".
    */
-  function drainGroup(group) {
-    const baseEE = agentIdentifier ? ee.get(agentIdentifier) : ee;
-    const handlers = defaultRegister.handlers;
-    if (!baseEE.backlog || !handlers) return;
-    var bufferedEventsInGroup = baseEE.backlog[group];
-    var groupHandlers = handlers[group];
-    if (groupHandlers) {
-      // We don't cache the length of the buffer while looping because events might still be added while processing.
-      for (var i = 0; bufferedEventsInGroup && i < bufferedEventsInGroup.length; ++i) {
-        // eslint-disable-line no-unmodified-loop-condition
-        emitEvent(bufferedEventsInGroup[i], groupHandlers);
-      }
-      mapOwn(groupHandlers, function (eventType, handlerRegistrationList) {
-        mapOwn(handlerRegistrationList, function (i, registration) {
-          // registration is an array of: [targetEE, eventHandler]
-          registration[0].on(eventType, registration[1]);
-        });
-      });
+function drainGroup(agentIdentifier, group) {
+  const baseEE = agentIdentifier ? ee.get(agentIdentifier) : ee;
+  const handlers = defaultRegister.handlers; // other storage in registerHandler
+  if (!baseEE.backlog || !handlers) return;
+  var bufferedEventsInGroup = baseEE.backlog[group];
+  var groupHandlers = handlers[group]; // each group in the registerHandler storage
+  if (groupHandlers) {
+    // We don't cache the length of the buffer while looping because events might still be added while processing.
+    for (var i = 0; bufferedEventsInGroup && i < bufferedEventsInGroup.length; ++i) {
+      // eslint-disable-line no-unmodified-loop-condition
+      emitEvent(bufferedEventsInGroup[i], groupHandlers);
     }
-    delete handlers[group];
-
-    // Keep the feature's event-group as a property of the event emitter so we know it was already created and drained.
-    baseEE.backlog[group] = null;
-    baseEE.emit('drain-' + group, []);
+    mapOwn(groupHandlers, function (eventType, handlerRegistrationList) {
+      mapOwn(handlerRegistrationList, function (i, registration) {
+        // registration is an array of: [targetEE, eventHandler]
+        registration[0].on(eventType, registration[1]);
+      });
+    });
   }
+  if (!baseEE.isolatedBacklog) delete handlers[group];
+  baseEE.backlog[group] = null;
+  baseEE.emit('drain-' + group, []);
 }
 
 /**

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

@@ -46,11 +46,26 @@ function ee(old, debugId) {
     context,
     buffer: bufferEventsByGroup,
     abort,
-    aborted: false,
     isBuffering,
     debugId,
-    backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {}
+    backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {},
+    isolatedBacklog
   };
+  function abort() {
+    emitter._aborted = true;
+    Object.keys(emitter.backlog).forEach(key => {
+      delete emitter.backlog[key];
+    });
+  }
+  Object.defineProperty(emitter, 'aborted', {
+    get: () => {
+      let aborted = emitter._aborted || false;
+      if (aborted) return aborted;else if (old) {
+        aborted = old.aborted;
+      }
+      return aborted;
+    }
+  });
   return emitter;
   function context(contextOrStore) {
     if (contextOrStore && contextOrStore instanceof EventContext) {
@@ -128,14 +143,4 @@ function ee(old, debugId) {
   function getBuffer() {
     return emitter.backlog;
   }
-}
-function abort() {
-  globalInstance.aborted = true;
-  // The global backlog can be referenced directly by other emitters,
-  // so we need to delete its contents as opposed to replacing it.
-  // Otherwise, these references to the old backlog would still exist
-  // and the keys will not be garbage collected.
-  Object.keys(globalInstance.backlog).forEach(key => {
-    delete globalInstance.backlog[key];
-  });
 }

package/dist/esm/common/harvest/harvest.js

@@ -177,7 +177,9 @@ export class Harvest extends SharedContext {
         // status 0 refers to a local error, such as CORS or network failure, or a blocked request by the browser (e.g. adblocker)
         const cbResult = {
           sent: this.status !== 0,
-          status: this.status
+          status: this.status,
+          xhr: this,
+          fullUrl
         };
         if (this.status === 429) {
           cbResult.retry = true;
@@ -191,6 +193,8 @@ export class Harvest extends SharedContext {
         cbFinished(cbResult);
       }, eventListenerOpts(false));
     }
+    const runtime = getRuntime(this.sharedContext.agentIdentifier);
+    runtime.harvestCount++;
     return result;
   }
 

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/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/timing/time-keeper.js

@@ -0,0 +1,88 @@
+import { gosNREUM } from '../window/nreum';
+import { globalScope } from '../constants/runtime';
+import { getRuntime } from '../config/config';
+
+/**
+ * Class used to adjust the timestamp of harvested data to New Relic server time. This
+ * is done by tracking the performance timings of the RUM call and applying a calculation
+ * to the harvested data event offset time.
+ */
+export class TimeKeeper {
+  #agent;
+
+  /**
+   * Represents the browser origin time corrected to NR server time.
+   * @type {number}
+   */
+  #correctedOriginTime;
+
+  /**
+   * Represents the difference in milliseconds between the calculated NR server time and
+   * the local time.
+   * @type {number}
+   */
+  #localTimeDiff;
+  constructor(agent) {
+    this.#agent = agent;
+  }
+  static getTimeKeeperByAgentIdentifier(agentIdentifier) {
+    const nr = gosNREUM();
+    return Object.keys(nr?.initializedAgents || {}).indexOf(agentIdentifier) > -1 ? nr.initializedAgents[agentIdentifier].timeKeeper : undefined;
+  }
+  get correctedPageOriginTime() {
+    return this.#correctedOriginTime;
+  }
+
+  /**
+   * Process a rum request to calculate NR server time.
+   * @param rumRequest {XMLHttpRequest} The xhr for the rum request
+   * @param rumRequestUrl {string} The full url of the rum request
+   */
+  processRumRequest(rumRequest, rumRequestUrl) {
+    const responseDateHeader = rumRequest.getResponseHeader('Date');
+    if (!responseDateHeader) {
+      throw new Error('Missing date header on rum response.');
+    }
+    const resourceEntries = globalScope.performance.getEntriesByName(rumRequestUrl, 'resource');
+    if (!Array.isArray(resourceEntries) || resourceEntries.length === 0) {
+      throw new Error('Missing rum request performance entry.');
+    }
+    let medianRumOffset = 0;
+    let serverOffset = 0;
+    if (typeof resourceEntries[0].responseStart === 'number' && resourceEntries[0].responseStart !== 0) {
+      // Cors is enabled and we can make a more accurate calculation of NR server time
+      medianRumOffset = (resourceEntries[0].responseStart - resourceEntries[0].requestStart) / 2;
+      serverOffset = Math.floor(resourceEntries[0].requestStart + medianRumOffset);
+    } else {
+      // Cors is disabled or erred, we need to use a less accurate calculation
+      medianRumOffset = (resourceEntries[0].responseEnd - resourceEntries[0].fetchStart) / 2;
+      serverOffset = Math.floor(resourceEntries[0].fetchStart + medianRumOffset);
+    }
+
+    // Corrected page origin time
+    this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset);
+    this.#localTimeDiff = getRuntime(this.#agent.agentIdentifier).offset - this.#correctedOriginTime;
+    if (Number.isNaN(this.#correctedOriginTime)) {
+      throw new Error('Date header invalid format.');
+    }
+  }
+
+  /**
+   * Converts a page origin relative time to an absolute timestamp
+   * corrected to NR server time.
+   * @param relativeTime {number} The relative time of the event in milliseconds
+   * @returns {number} The correct timestamp as a unix/epoch timestamp value
+   */
+  convertRelativeTimestamp(relativeTime) {
+    return this.#correctedOriginTime + relativeTime;
+  }
+
+  /**
+   * Corrects an event timestamp to NR server time.
+   * @param timestamp {number} The unix/epoch timestamp of the event with milliseconds
+   * @return {number} Corrected unix/epoch timestamp
+   */
+  correctAbsoluteTimestamp(timestamp) {
+    return Math.floor(timestamp - this.#localTimeDiff);
+  }
+}

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

@@ -3,47 +3,30 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { ee } from '../event-emitter/contextual-ee';
-import { handle } from '../event-emitter/handle';
-import { FEATURE_NAMES } from '../../loaders/features/features';
 import { dispatchGlobalEvent } from '../dispatch/global-event';
-const bucketMap = {
-  stn: [FEATURE_NAMES.sessionTrace],
-  err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
-  ins: [FEATURE_NAMES.pageAction],
-  spa: [FEATURE_NAMES.spa],
-  sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
-};
 const sentIds = new Set();
 
-/** Note that this function only processes each unique flag ONCE, with the first occurrence of each flag and numeric value determining its switch on/off setting. */
+/** A map of feature flags and their values as provided by the rum call -- scoped by agent ID */
+export const activatedFeatures = {};
+
+/**
+ * Sets the activatedFeatures object, dispatches the global loaded event,
+ * and emits the rumresp flag to features
+ * @param {{[key:string]:number}} flags key-val pair of flag names and numeric
+ * @param {string} agentIdentifier agent instance identifier
+ * @returns {void}
+ */
 export function activateFeatures(flags, agentIdentifier) {
   const sharedEE = ee.get(agentIdentifier);
+  activatedFeatures[agentIdentifier] ??= {};
   if (!(flags && typeof flags === 'object')) return;
   if (sentIds.has(agentIdentifier)) return;
-  Object.entries(flags).forEach(_ref => {
-    let [flag, num] = _ref;
-    if (bucketMap[flag]) {
-      bucketMap[flag].forEach(feat => {
-        if (!num) handle('block-' + flag, [], undefined, feat, sharedEE);else handle('feat-' + flag, [], undefined, feat, sharedEE);
-        handle('rumresp-' + flag, [Boolean(num)], undefined, feat, sharedEE); // this is a duplicate of feat-/block- but makes awaiting for 1 event easier than 2
-      });
-    } else if (num) handle('feat-' + flag, [], undefined, undefined, sharedEE); // not sure what other flags are overlooked, but there's a test for ones not in the map --
-    activatedFeatures[flag] = Boolean(num);
-  });
-
-  // Let the features waiting on their respective flags know that RUM response was received and that any missing flags are interpreted as bad entitlement / "off".
-  // Hence, those features will not be hanging forever if their flags aren't included in the response.
-  Object.keys(bucketMap).forEach(flag => {
-    if (activatedFeatures[flag] === undefined) {
-      bucketMap[flag]?.forEach(feat => handle('rumresp-' + flag, [false], undefined, feat, sharedEE));
-      activatedFeatures[flag] = false;
-    }
-  });
+  sharedEE.emit('rumresp', [flags]);
+  activatedFeatures[agentIdentifier] = flags;
   sentIds.add(agentIdentifier);
 
   // let any window level subscribers know that the agent is running
   dispatchGlobalEvent({
     loaded: true
   });
-}
-export const activatedFeatures = {};
+}

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/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,17 +14,21 @@ 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);
-    if (!allAjaxIsEnabled) {
+    registerHandler('xhr', storeXhr, this.featureName, this.ee);
+    this.waitForFlags([]).then(() => {
+      const scheduler = new HarvestScheduler('events', {
+        onFinished: onEventsHarvestFinished,
+        getPayload: prepareHarvest
+      }, this);
+      scheduler.startTimer(harvestTimeSeconds);
       this.drain();
-      return; // feature will only collect timeslice metrics & ajax trace nodes if it's not fully enabled
-    }
+    });
     const denyList = getRuntime(agentIdentifier).denyList;
     setDenyList(denyList);
     let ajaxEvents = [];
@@ -43,27 +47,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];
     });
-    const scheduler = new HarvestScheduler('events', {
-      onFinished: onEventsHarvestFinished,
-      getPayload: prepareHarvest
-    }, this);
-    ee.on("drain-".concat(this.featureName), () => {
-      scheduler.startTimer(harvestTimeSeconds);
-    });
-    this.drain();
+    // --- ^
+    // --- v Used by new soft nav
+    registerHandler('returnAjax', event => ajaxEvents.push(event), this.featureName, this.ee);
+    // --- ^
+
     const beacon = getInfo(agentIdentifier).errorBeacon;
     const proxyBeacon = agentInit.proxy.beacon;
     function storeXhr(params, metrics, startTime, endTime, type) {
@@ -76,16 +76,25 @@ 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 (!allAjaxIsEnabled) return;
-      if (!shouldCollectEvent(params)) {
+      if (shouldCollect || !ajaxMetricDenyListEnabled) {
+        aggregator.store('xhr', hash, params, metrics);
+      }
+      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 +124,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 {