@newrelic/browser-agent 1.252.1 → 1.254.0

package/src/cdn/experimental.js

@@ -17,7 +17,8 @@ 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({
@@ -30,7 +31,8 @@ new Agent({
     InstrumentMetrics,
     InstrumentPageAction,
     InstrumentErrors,
-    InstrumentSpa
+    // InstrumentSpa,
+    InstrumentSoftNav
   ],
   loaderType: 'experimental'
 })

package/src/cdn/polyfills.js

@@ -22,3 +22,4 @@ import 'core-js/stable/object/get-own-property-descriptors'
 import 'core-js/stable/url'
 import 'core-js/stable/url-search-params'
 import 'core-js/stable/string/starts-with'
+import 'core-js/stable/number/is-nan'

package/src/cdn/spa.js

@@ -11,6 +11,7 @@ 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'
 
@@ -24,7 +25,8 @@ new Agent({
     InstrumentMetrics,
     InstrumentPageAction,
     InstrumentErrors,
-    InstrumentSpa
+    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/src/common/aggregate/aggregator.js

@@ -82,7 +82,8 @@ 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]
     }
@@ -159,13 +160,3 @@ function createMetricObject (value) {
     c: 1
   }
 }
-
-function toArray (obj) {
-  if (typeof obj !== 'object') return []
-
-  return mapOwn(obj, getValue)
-}
-
-function getValue (key, value) {
-  return value
-}

package/src/common/config/state/init.js

@@ -64,6 +64,7 @@ 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, // float from 0 - 100
       collect_fonts: false, // serialize fonts for collection without public asset url, this is currently broken in RRWeb -- https://github.com/rrweb-io/rrweb/issues/1304.  When fixed, revisit with test cases
@@ -100,7 +101,8 @@ const model = () => {
         else warn('An invalid session_replay.mask_input_option was provided and will not be used', val)
       }
     },
-    spa: { enabled: true, harvestTimeSeconds: 10, autoStart: true }
+    spa: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
+    soft_navigations: { enabled: true, harvestTimeSeconds: 10, autoStart: true }
   }
 }
 

package/src/common/config/state/runtime.js

@@ -18,10 +18,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 = {}

package/src/common/drain/drain.js

@@ -26,13 +26,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()
 }
 
@@ -48,54 +59,56 @@ export function drain (agentIdentifier = '', featureName = 'feature', force = fa
   // 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
 
-  // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
+  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]]
   if (items.every(([key, values]) => values.staged)) {
     items.sort((a, b) => a[1].priority - b[1].priority)
     items.forEach(([group]) => {
       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
+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]
-    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])
-        })
-      })
+  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/src/common/event-emitter/contextual-ee.js

@@ -49,13 +49,32 @@ 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) {
@@ -141,14 +160,3 @@ function ee (old, debugId) {
     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/src/common/harvest/harvest.js

@@ -145,7 +145,7 @@ export class Harvest extends SharedContext {
       result.addEventListener('loadend', function () {
         // `this` refers to the XHR object in this scope, do not change this to a fat arrow
         // 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 }
+        const cbResult = { sent: this.status !== 0, status: this.status, xhr: this, fullUrl }
         if (this.status === 429) {
           cbResult.retry = true
           cbResult.delay = harvestScope.tooManyRequestsDelay
@@ -160,6 +160,9 @@ export class Harvest extends SharedContext {
       }, eventListenerOpts(false))
     }
 
+    const runtime = getRuntime(this.sharedContext.agentIdentifier)
+    runtime.harvestCount++
+
     return result
   }
 

package/src/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
 

package/src/common/timing/nav-timing.js

@@ -25,7 +25,7 @@ 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
@@ -72,6 +72,10 @@ export function addPN (pn, v) {
   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.
@@ -85,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/src/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/src/common/timing/time-keeper.js

@@ -0,0 +1,96 @@
+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/src/common/util/feature-flags.js

@@ -3,49 +3,31 @@
  * 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(([flag, num]) => {
-    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)
-  })
+  sharedEE.emit('rumresp', [flags])
+  activatedFeatures[agentIdentifier] = flags
 
-  // 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
-    }
-  })
   sentIds.add(agentIdentifier)
 
   // let any window level subscribers know that the agent is running
   dispatchGlobalEvent({ loaded: true })
 }
-
-export const activatedFeatures = {}

package/src/common/wrap/index.js

@@ -8,10 +8,9 @@ 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
+  wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapTimer, wrapXhr
 }

package/src/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,19 +14,24 @@ 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)
@@ -44,29 +49,21 @@ export class Aggregate extends AggregateBase {
     this.prepareHarvest = prepareHarvest
     this.getStoredEvents = function () { return { ajaxEvents, 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-${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
@@ -82,17 +79,28 @@ export class Aggregate extends AggregateBase {
         hash = stringify([params.status, params.host, params.pathname])
       }
 
-      // store as metric
-      aggregator.store('xhr', hash, params, metrics)
+      const shouldCollect = shouldCollectEvent(params)
+      const ajaxMetricDenyListEnabled = agentInit.feature_flags?.includes('ajax_metrics_deny_list')
 
-      if (!allAjaxIsEnabled) return
+      // store as metric
+      if (shouldCollect || !ajaxMetricDenyListEnabled) {
+        aggregator.store('xhr', hash, params, metrics)
+      }
 
-      if (!shouldCollectEvent(params)) {
+      if (!shouldCollect) {
         if (params.hostname === beacon || (proxyBeacon && params.hostname === proxyBeacon)) {
           // This doesn't make a distinction if the same-domain request is going to a different port or path...
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee)
+
+          if (ajaxMetricDenyListEnabled) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee)
+          }
         } else {
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee)
+
+          if (ajaxMetricDenyListEnabled) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee)
+          }
         }
         return
       }
@@ -125,12 +133,13 @@ export class Aggregate extends AggregateBase {
         body: this.body,
         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 {
@@ -209,6 +218,7 @@ export class Aggregate extends AggregateBase {
 
       for (var i = 0; i < events.length; i++) {
         var event = events[i]
+
         var fields = [
           numeric(event.startTime),
           numeric(event.endTime - event.startTime),