@newrelic/browser-agent 1.298.0 → 1.299.0

package/src/common/harvest/harvester.js

@@ -135,14 +135,16 @@ export function send (agentRef, { endpoint, targetApp, payload, localOpts = {},
 
   const fullUrl = `${url}?${baseParams}${payloadParams}`
   const gzip = !!qs?.attributes?.includes('gzip')
-  if (!gzip) {
-    if (endpoint !== EVENTS) body = stringify(body) // all features going to 'events' endpoint should already be serialized & stringified
-    // Warn--once per endpoint--if the agent tries to send large payloads
-    if (body.length > 750000 && (warnings[endpoint] = (warnings[endpoint] || 0) + 1) === 1) warn(28, endpoint)
-  }
+
+  // all gzipped data is already in the correct format and needs no transformation
+  // all features going to 'events' endpoint should already be serialized & stringified
+  let stringBody = gzip || endpoint === EVENTS ? body : stringify(body)
 
   // If body is null, undefined, or an empty object or array after stringifying, send an empty string instead.
-  if (!body || body.length === 0 || body === '{}' || body === '[]') body = ''
+  if (!stringBody || stringBody.length === 0 || stringBody === '{}' || stringBody === '[]') stringBody = ''
+
+  // Warn--once per endpoint--if the agent tries to send large payloads
+  if (endpoint !== BLOBS && stringBody.length > 750000 && (warnings[endpoint] = (warnings[endpoint] || 0) + 1) === 1) warn(28, endpoint)
 
   const headers = [{ key: 'content-type', value: 'text/plain' }]
 
@@ -150,7 +152,7 @@ export function send (agentRef, { endpoint, targetApp, payload, localOpts = {},
       Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
       we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon.
      Following the removal of img-element method. */
-  let result = submitMethod({ url: fullUrl, body, sync: localOpts.isFinalHarvest && isWorkerScope, headers })
+  let result = submitMethod({ url: fullUrl, body: stringBody, sync: localOpts.isFinalHarvest && isWorkerScope, headers })
 
   if (!localOpts.isFinalHarvest && cbFinished) { // final harvests don't hold onto buffer data (shouldRetryOnFail is false), so cleanup isn't needed
     if (submitMethod === xhrMethod) {
@@ -160,6 +162,9 @@ export function send (agentRef, { endpoint, targetApp, payload, localOpts = {},
         const cbResult = { sent: this.status !== 0, status: this.status, retry: shouldRetry(this.status), fullUrl, xhr: this, targetApp }
         if (localOpts.needResponse) cbResult.responseText = this.responseText
         cbFinished(cbResult)
+
+        /** temporary audit of consistency of harvest metadata flags */
+        if (!shouldRetry(this.status)) trackHarvestMetadata()
       }, eventListenerOpts(false))
     } else if (submitMethod === fetchMethod) {
       result.then(async function (response) {
@@ -167,8 +172,30 @@ export function send (agentRef, { endpoint, targetApp, payload, localOpts = {},
         const cbResult = { sent: true, status, retry: shouldRetry(status), fullUrl, fetchResponse: response, targetApp }
         if (localOpts.needResponse) cbResult.responseText = await response.text()
         cbFinished(cbResult)
+        /** temporary audit of consistency of harvest metadata flags */
+        if (!shouldRetry(status)) trackHarvestMetadata()
       })
     }
+
+    function trackHarvestMetadata () {
+      try {
+        if (featureName === FEATURE_NAMES.jserrors && !body?.err) return
+
+        const hasReplay = baseParams.includes('hr=1')
+        const hasTrace = baseParams.includes('ht=1')
+        const hasError = qs?.attributes?.includes('hasError=true')
+
+        handle('harvest-metadata', [{
+          [featureName]: {
+            ...(hasReplay && { hasReplay }),
+            ...(hasTrace && { hasTrace }),
+            ...(hasError && { hasError })
+          }
+        }], undefined, FEATURE_NAMES.metrics, agentRef.ee)
+      } catch (err) {
+      // do nothing
+      }
+    }
   }
 
   dispatchGlobalEvent({

package/src/common/url/extract-url.js

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { globalScope } from '../constants/runtime'
+import { gosNREUMOriginals } from '../window/nreum'
+
+/**
+ * Extracts a URL from various target types.
+ * @param {string|Request|URL} target - The target to extract the URL from. It can be a string, a Fetch Request object, or a URL object.
+ * @returns {string|undefined} The extracted URL as a string, or undefined if the target type is not supported.
+ */
+export function extractUrl (target) {
+  if (typeof target === 'string') return target
+  else if (target instanceof gosNREUMOriginals().o.REQ) return target.url
+  else if (globalScope?.URL && target instanceof URL) return target.href
+}

package/src/features/ajax/instrument/index.js

@@ -19,6 +19,7 @@ import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC } from '../../metrics/constants'
 import { now } from '../../../common/timing/now'
 import { hasUndefinedHostname } from '../../../common/deny-list/deny-list'
+import { extractUrl } from '../../../common/url/extract-url'
 
 var handlers = ['load', 'error', 'abort', 'timeout']
 var handlersLen = handlers.length
@@ -318,16 +319,7 @@ function subscribeToEvents (agentRef, ee, handler, dt) {
 
     var opts = this.opts || {}
     var target = this.target
-
-    var url
-    if (typeof target === 'string') {
-      url = target
-    } else if (typeof target === 'object' && target instanceof origRequest) {
-      url = target.url
-    } else if (globalScope?.URL && typeof target === 'object' && target instanceof URL) {
-      url = target.href
-    }
-    addUrl(this, url)
+    addUrl(this, extractUrl(target))
 
     var method = ('' + ((target && target instanceof origRequest && target.method) ||
       opts.method || 'GET')).toUpperCase()

package/src/features/generic_events/aggregate/index.js

@@ -17,6 +17,8 @@ import { isPureObject } from '../../../common/util/type-check'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
+  #userActionAggregator
+
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
     this.referrerUrl = (isBrowserScope && document.referrer) ? cleanURL(document.referrer) : undefined
@@ -28,7 +30,7 @@ export class Aggregate extends AggregateBase {
         return
       }
 
-      this.trackSupportabilityMetrics()
+      this.#trackSupportabilityMetrics()
 
       registerHandler('api-recordCustomEvent', (timestamp, eventType, attributes) => {
         if (RESERVED_EVENT_TYPES.includes(eventType)) return warn(46)
@@ -59,8 +61,8 @@ export class Aggregate extends AggregateBase {
 
       let addUserAction = () => { /** no-op */ }
       if (isBrowserScope && agentRef.init.user_actions.enabled) {
-        this.userActionAggregator = new UserActionsAggregator()
-        this.harvestOpts.beforeUnload = () => addUserAction?.(this.userActionAggregator.aggregationEvent)
+        this.#userActionAggregator = new UserActionsAggregator(agentRef.init.feature_flags.includes('user_frustrations'))
+        this.harvestOpts.beforeUnload = () => addUserAction?.(this.#userActionAggregator.aggregationEvent)
 
         addUserAction = (aggregatedUserAction) => {
           try {
@@ -68,7 +70,7 @@ export class Aggregate extends AggregateBase {
              * so we still need to validate that an event was given to this method before we try to add */
             if (aggregatedUserAction?.event) {
               const { target, timeStamp, type } = aggregatedUserAction.event
-              this.addEvent({
+              const userActionEvent = {
                 eventType: 'UserAction',
                 timestamp: this.toEpoch(timeStamp),
                 action: type,
@@ -84,8 +86,12 @@ export class Aggregate extends AggregateBase {
                   if (canTrustTargetAttribute(field)) acc[targetAttrName(field)] = String(target[field]).trim().slice(0, 128)
                   return acc
                 }, {})),
-                ...aggregatedUserAction.nearestTargetFields
-              })
+                ...aggregatedUserAction.nearestTargetFields,
+                ...(aggregatedUserAction.deadClick && { deadClick: true }),
+                ...(aggregatedUserAction.errorClick && { errorClick: true })
+              }
+              this.addEvent(userActionEvent)
+              this.#trackUserActionSM(userActionEvent)
 
               /**
                * Returns the original target field name with `target` prepended and camelCased
@@ -116,8 +122,11 @@ export class Aggregate extends AggregateBase {
 
         registerHandler('ua', (evt) => {
           /** the processor will return the previously aggregated event if it has been completed by processing the current event */
-          addUserAction(this.userActionAggregator.process(evt, this.agentRef.init.user_actions.elementAttributes))
+          addUserAction(this.#userActionAggregator.process(evt, this.agentRef.init.user_actions.elementAttributes))
         }, this.featureName, this.ee)
+        registerHandler('navChange', () => { this.#userActionAggregator.isLiveClick() }, this.featureName, this.ee)
+        registerHandler('uaXhr', () => { this.#userActionAggregator.isLiveClick() }, this.featureName, this.ee)
+        registerHandler('uaErr', () => this.#userActionAggregator.markAsErrorClick(), this.featureName, this.ee)
       }
 
       /**
@@ -296,7 +305,7 @@ export class Aggregate extends AggregateBase {
     return Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp))
   }
 
-  trackSupportabilityMetrics () {
+  #trackSupportabilityMetrics () {
     /** track usage SMs to improve these experimental features */
     const configPerfTag = 'Config/Performance/'
     if (this.agentRef.init.performance.capture_marks) this.reportSupportabilityMetric(configPerfTag + 'CaptureMarks/Enabled')
@@ -306,4 +315,10 @@ export class Aggregate extends AggregateBase {
     if (this.agentRef.init.performance.resources.first_party_domains?.length !== 0) this.reportSupportabilityMetric(configPerfTag + 'Resources/FirstPartyDomains/Changed')
     if (this.agentRef.init.performance.resources.ignore_newrelic === false) this.reportSupportabilityMetric(configPerfTag + 'Resources/IgnoreNewrelic/Changed')
   }
+
+  #trackUserActionSM (ua) {
+    if (ua.rageClick) this.reportSupportabilityMetric('UserAction/RageClick/Seen')
+    if (ua.deadClick) this.reportSupportabilityMetric('UserAction/DeadClick/Seen')
+    if (ua.errorClick) this.reportSupportabilityMetric('UserAction/ErrorClick/Seen')
+  }
 }

package/src/features/generic_events/aggregate/user-actions/aggregated-user-action.js

@@ -6,15 +6,17 @@ import { RAGE_CLICK_THRESHOLD_EVENTS, RAGE_CLICK_THRESHOLD_MS } from '../../cons
 import { cleanURL } from '../../../../common/url/clean-url'
 
 export class AggregatedUserAction {
-  constructor (evt, selectorPath, nearestTargetFields) {
+  constructor (evt, selectorInfo) {
     this.event = evt
     this.count = 1
     this.originMs = Math.floor(evt.timeStamp)
     this.relativeMs = [0]
-    this.selectorPath = selectorPath
+    this.selectorPath = selectorInfo.path
     this.rageClick = undefined
-    this.nearestTargetFields = nearestTargetFields
+    this.nearestTargetFields = selectorInfo.nearestFields
     this.currentUrl = cleanURL('' + location)
+    this.deadClick = false
+    this.errorClick = false
   }
 
   /**

package/src/features/generic_events/aggregate/user-actions/user-actions-aggregator.js

@@ -2,14 +2,27 @@
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { generateSelectorPath } from '../../../../common/dom/selector-path'
-import { OBSERVED_WINDOW_EVENTS } from '../../constants'
+import { analyzeElemPath } from '../../../../common/dom/selector-path'
+import { FRUSTRATION_TIMEOUT_MS, OBSERVED_WINDOW_EVENTS } from '../../constants'
 import { AggregatedUserAction } from './aggregated-user-action'
+import { Timer } from '../../../../common/timer/timer'
+import { gosNREUMOriginals } from '../../../../common/window/nreum'
 
 export class UserActionsAggregator {
   /** @type {AggregatedUserAction=} */
   #aggregationEvent = undefined
   #aggregationKey = ''
+  #ufEnabled = false
+  #deadClickTimer = undefined
+  #domObserver = undefined
+  #errorClickTimer = undefined
+
+  constructor (userFrustrationsEnabled) {
+    if (userFrustrationsEnabled && gosNREUMOriginals().o.MO) {
+      this.#domObserver = new MutationObserver(this.isLiveClick.bind(this))
+      this.#ufEnabled = true
+    }
+  }
 
   get aggregationEvent () {
     // if this is accessed externally, we need to be done aggregating on it
@@ -28,40 +41,83 @@ export class UserActionsAggregator {
    */
   process (evt, targetFields) {
     if (!evt) return
-    const { selectorPath, nearestTargetFields } = getSelectorPath(evt, targetFields)
-    const aggregationKey = getAggregationKey(evt, selectorPath)
+    const targetElem = OBSERVED_WINDOW_EVENTS.includes(evt.type) ? window : evt.target
+    const selectorInfo = analyzeElemPath(targetElem, targetFields)
+
+    // if selectorInfo.path is undefined, aggregation will be skipped for this event
+    const aggregationKey = getAggregationKey(evt, selectorInfo.path)
     if (!!aggregationKey && aggregationKey === this.#aggregationKey) {
       // an aggregation exists already, so lets just continue to increment
       this.#aggregationEvent.aggregate(evt)
     } else {
       // return the prev existing one (if there is one)
       const finishedEvent = this.#aggregationEvent
-      // then set as this new event aggregation
+      if (this.#ufEnabled) {
+        this.#deadClickCleanup()
+        this.#errorClickCleanup()
+      }
+
+      // then start new event aggregation
       this.#aggregationKey = aggregationKey
-      this.#aggregationEvent = new AggregatedUserAction(evt, selectorPath, nearestTargetFields)
+      this.#aggregationEvent = new AggregatedUserAction(evt, selectorInfo)
+      if (this.#ufEnabled && evt.type === 'click' && (selectorInfo.hasButton || selectorInfo.hasLink)) {
+        this.#deadClickSetup(this.#aggregationEvent)
+        this.#errorClickSetup()
+      }
       return finishedEvent
     }
   }
-}
 
-/**
- * Generates a selector path for the event, starting with simple cases like window or document and getting more complex for dom-tree traversals as needed.
- * Will return a random selector path value if no other path can be determined, to force the aggregator to skip aggregation for this event.
- * @param {Event} evt
- * @returns {string}
- */
-function getSelectorPath (evt, targetFields) {
-  let selectorPath; let nearestTargetFields = {}
-  if (OBSERVED_WINDOW_EVENTS.includes(evt.type) || evt.target === window) selectorPath = 'window'
-  else if (evt.target === document) selectorPath = 'document'
-  // if still no selectorPath, generate one from target tree that includes elem ids
-  else {
-    const { path, nearestFields } = generateSelectorPath(evt.target, targetFields)
-    selectorPath = path
-    nearestTargetFields = nearestFields
+  markAsErrorClick () {
+    if (this.#aggregationEvent && this.#errorClickTimer) {
+      this.#aggregationEvent.errorClick = true
+      this.#errorClickCleanup()
+    }
+  }
+
+  #errorClickSetup () {
+    this.#errorClickTimer = new Timer({
+      onEnd: () => {
+        this.#errorClickCleanup()
+      }
+    }, FRUSTRATION_TIMEOUT_MS)
+  }
+
+  #errorClickCleanup () {
+    this.#errorClickTimer?.clear()
+    this.#errorClickTimer = undefined
+  }
+
+  #deadClickSetup (userAction) {
+    if (this.#isEvaluatingDeadClick() || !this.#domObserver) return
+
+    this.#domObserver.observe(document, {
+      attributes: true,
+      characterData: true,
+      childList: true,
+      subtree: true
+    })
+    this.#deadClickTimer = new Timer({
+      onEnd: () => {
+        userAction.deadClick = true
+        this.#deadClickCleanup()
+      }
+    }, FRUSTRATION_TIMEOUT_MS)
+  }
+
+  #deadClickCleanup () {
+    this.#domObserver?.disconnect()
+    this.#deadClickTimer?.clear()
+    this.#deadClickTimer = undefined
+  }
+
+  #isEvaluatingDeadClick () {
+    return this.#deadClickTimer !== undefined
+  }
+
+  isLiveClick () {
+    if (this.#isEvaluatingDeadClick()) this.#deadClickCleanup()
   }
-  // if STILL no selectorPath, it will return undefined which will skip aggregation for this event
-  return { selectorPath, nearestTargetFields }
 }
 
 /**

package/src/features/generic_events/constants.js

@@ -12,6 +12,8 @@ export const OBSERVED_WINDOW_EVENTS = ['focus', 'blur']
 export const RAGE_CLICK_THRESHOLD_EVENTS = 4
 export const RAGE_CLICK_THRESHOLD_MS = 1000
 
+export const FRUSTRATION_TIMEOUT_MS = 2000
+
 export const RESERVED_EVENT_TYPES = ['PageAction', 'UserAction', 'BrowserPerformance']
 
 export const FEATURE_FLAGS = {

package/src/features/generic_events/instrument/index.js

@@ -5,7 +5,7 @@
 
 import { globalScope, isBrowserScope } from '../../../common/constants/runtime'
 import { handle } from '../../../common/event-emitter/handle'
-import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
+import { eventListenerOpts, windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
 import { debounce } from '../../../common/util/invoke'
 import { setupAddPageActionAPI } from '../../../loaders/api/addPageAction'
 import { setupFinishedAPI } from '../../../loaders/api/finished'
@@ -14,6 +14,12 @@ import { setupRegisterAPI } from '../../../loaders/api/register'
 import { setupMeasureAPI } from '../../../loaders/api/measure'
 import { InstrumentBase } from '../../utils/instrument-base'
 import { FEATURE_NAME, OBSERVED_EVENTS, OBSERVED_WINDOW_EVENTS } from '../constants'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
+import { wrapHistory } from '../../../common/wrap/wrap-history'
+import { wrapFetch } from '../../../common/wrap/wrap-fetch'
+import { wrapXhr } from '../../../common/wrap/wrap-xhr'
+import { parseUrl } from '../../../common/url/parse-url'
+import { extractUrl } from '../../../common/url/extract-url'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
@@ -55,6 +61,50 @@ export class Instrument extends InstrumentBase {
         })
         observer.observe({ type: 'resource', buffered: true })
       }
+
+      const historyEE = wrapHistory(this.ee)
+      historyEE.on('pushState-end', navigationChange)
+      historyEE.on('replaceState-end', navigationChange)
+      window.addEventListener('hashchange', navigationChange, eventListenerOpts(true, this.removeOnAbort?.signal))
+      window.addEventListener('popstate', navigationChange, eventListenerOpts(true, this.removeOnAbort?.signal))
+      function navigationChange () {
+        historyEE.emit('navChange')
+      }
+    }
+
+    try {
+      this.removeOnAbort = new AbortController()
+    } catch (e) {}
+
+    this.abortHandler = () => {
+      this.removeOnAbort?.abort()
+      this.abortHandler = undefined // weakly allow this abort op to run only once
+    }
+
+    globalScope.addEventListener('error', () => {
+      handle('uaErr', [], undefined, FEATURE_NAMES.genericEvents, this.ee)
+    }, eventListenerOpts(false, this.removeOnAbort?.signal))
+
+    wrapFetch(this.ee)
+    wrapXhr(this.ee)
+    this.ee.on('open-xhr-start', (args, xhr) => {
+      if (!isInternalTraffic(args[1])) {
+        xhr.addEventListener('readystatechange', () => {
+          if (xhr.readyState === 2) { // HEADERS_RECEIVED
+            handle('uaXhr', [], undefined, FEATURE_NAMES.genericEvents, this.ee)
+          }
+        })
+      }
+    })
+    this.ee.on('fetch-start', (fetchArguments) => {
+      if (fetchArguments.length >= 1 && !isInternalTraffic(extractUrl(fetchArguments[0]))) {
+        handle('uaXhr', [], undefined, FEATURE_NAMES.genericEvents, this.ee)
+      }
+    })
+
+    function isInternalTraffic (url) {
+      const parsedUrl = parseUrl(url)
+      return agentRef.beacons.includes(parsedUrl.hostname + ':' + parsedUrl.port)
     }
 
     /** If any of the sources are active, import the aggregator. otherwise deregister */

package/src/features/metrics/aggregate/framework-detection.js

@@ -28,6 +28,7 @@ const FRAMEWORKS = {
   JQUERY: 'Jquery',
   MOOTOOLS: 'MooTools',
   QWIK: 'Qwik',
+  FLUTTER: 'Flutter',
 
   ELECTRON: 'Electron'
 }
@@ -71,6 +72,7 @@ export function getFrameworks () {
     if (Object.prototype.hasOwnProperty.call(window, 'jQuery')) frameworks.push(FRAMEWORKS.JQUERY)
     if (Object.prototype.hasOwnProperty.call(window, 'MooTools')) frameworks.push(FRAMEWORKS.MOOTOOLS)
     if (Object.prototype.hasOwnProperty.call(window, 'qwikevents')) frameworks.push(FRAMEWORKS.QWIK)
+    if (Object.hasOwn(window, '_flutter')) frameworks.push(FRAMEWORKS.FLUTTER)
 
     if (detectElectron()) frameworks.push(FRAMEWORKS.ELECTRON)
   } catch (err) {

package/src/features/metrics/aggregate/harvest-metadata.js

@@ -0,0 +1,42 @@
+/**
+ * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export function evaluateHarvestMetadata (pageMetadata) {
+  try {
+    const supportabilityTags = []
+
+    // Report SM like... audit/<feature_name>/<hasReplay|hasTrace|hasError>/<true|false>/<negative|positive>
+    const formTag = (...strings) => strings.join('/')
+
+    // Track if replay/trace/error harvests actually occurred (key only exists when harvested)
+    function evaluateTag (feature, flag, hasFlag, hasHarvest) {
+      const AUDIT = 'audit'
+      if (hasFlag) {
+      // False positive: flag true, but no harvest
+        if (!hasHarvest) supportabilityTags.push(formTag(AUDIT, feature, flag, 'false', 'positive'))
+        // True positive (correct)
+        else supportabilityTags.push(formTag(AUDIT, feature, flag, 'true', 'positive'))
+      } else {
+      // False negative: flag false, but harvest occurred
+        if (hasHarvest) supportabilityTags.push(formTag(AUDIT, feature, flag, 'false', 'negative'))
+        // True negative (correct)
+        else supportabilityTags.push(formTag(AUDIT, feature, flag, 'true', 'negative'))
+      }
+    }
+
+    if (pageMetadata.page_view_event) {
+      evaluateTag('page_view', 'hasReplay', pageMetadata.page_view_event.hasReplay, !!pageMetadata.session_replay)
+      evaluateTag('page_view', 'hasTrace', pageMetadata.page_view_event.hasTrace, !!pageMetadata.session_trace)
+    }
+
+    if (pageMetadata.session_replay) {
+      evaluateTag('session_replay', 'hasError', pageMetadata.session_replay.hasError, !!pageMetadata.jserrors)
+    }
+
+    return supportabilityTags
+  } catch (err) {
+    return []
+  }
+}

package/src/features/metrics/aggregate/index.js

@@ -11,6 +11,7 @@ import { windowAddEventListener } from '../../../common/event-listener/event-lis
 import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { isIFrameWindow } from '../../../common/dom/iframe'
+import { evaluateHarvestMetadata } from './harvest-metadata'
 // import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
 // import { handleWebsocketEvents } from './websocket-detection'
 
@@ -19,6 +20,15 @@ export class Aggregate extends AggregateBase {
   constructor (agentRef) {
     super(agentRef, FEATURE_NAME)
     this.harvestOpts.aggregatorTypes = ['cm', 'sm'] // the types in EventAggregator this feature cares about
+
+    /** all the harvest metadata metrics need to be evaluated simulataneously at unload time so just temporarily buffer them and dont make SMs immediately from the data */
+    this.harvestMetadata = {}
+    this.harvestOpts.beforeUnload = () => {
+      evaluateHarvestMetadata(this.harvestMetadata).forEach(smTag => {
+        this.storeSupportabilityMetrics(smTag)
+      })
+    }
+
     // This feature only harvests once per potential EoL of the page, which is handled by the central harvester.
 
     // this must be read/stored synchronously, as the currentScript is removed from the DOM after this script is executed and this lookup will be void
@@ -126,6 +136,17 @@ export class Aggregate extends AggregateBase {
     //     handleWebsocketEvents(this.storeSupportabilityMetrics.bind(this), tag, ...args)
     //   }, this.featureName, this.ee)
     // })
+
+    /** all the harvest metadata metrics need to be evaluated simulataneously at unload time so just temporarily buffer them and dont make SMs immediately from the data */
+    registerHandler('harvest-metadata', (harvestMetadataObject = {}) => {
+      try {
+        Object.keys(harvestMetadataObject).forEach(key => {
+          Object.assign(this.harvestMetadata[key] ??= {}, harvestMetadataObject[key])
+        })
+      } catch (e) {
+      // failed to merge harvest metadata... ignore
+      }
+    }, this.featureName, this.ee)
   }
 
   eachSessionChecks () {

package/src/features/session_replay/aggregate/index.js

@@ -136,7 +136,7 @@ export class Aggregate extends AggregateBase {
       if (!this.agentRef.runtime.isRecording) this.recorder.startRecording(TRIGGERS.SWITCH_TO_FULL, this.mode) // off --> full
       this.syncWithSessionManager({ sessionReplayMode: this.mode })
     } else {
-      this.initializeRecording(MODE.FULL, true)
+      this.initializeRecording(MODE.FULL, true, TRIGGERS.SWITCH_TO_FULL)
     }
   }
 

package/src/features/session_replay/shared/recorder.js

@@ -57,7 +57,11 @@ export class Recorder {
       this.stopRecording()
     }, this.srFeatureName, this.ee)
 
-    registerHandler(RRWEB_DATA_CHANNEL, (event, isCheckout) => { this.audit(event, isCheckout) }, this.srFeatureName, this.ee)
+    /** If Agg is already drained before importing the recorder (likely deferred API call pattern),
+     * registerHandler wont do anything. Just set up the on listener directly */
+    const processReplayNode = (event, isCheckout) => { this.audit(event, isCheckout) }
+    if (this.srInstrument.featAggregate?.drained) this.ee.on(RRWEB_DATA_CHANNEL, processReplayNode)
+    else registerHandler(RRWEB_DATA_CHANNEL, processReplayNode, this.srFeatureName, this.ee)
   }
 
   get trigger () {

package/src/loaders/api/noticeError.js

@@ -15,4 +15,5 @@ export function setupNoticeErrorAPI (agent) {
 export function noticeError (err, customAttributes, agentRef, targetEntityGuid, timestamp = now()) {
   if (typeof err === 'string') err = new Error(err)
   handle('err', [err, timestamp, false, customAttributes, agentRef.runtime.isRecording, undefined, targetEntityGuid], undefined, FEATURE_NAMES.jserrors, agentRef.ee)
+  handle('uaErr', [], undefined, FEATURE_NAMES.genericEvents, agentRef.ee)
 }

package/src/loaders/configure/configure.js

@@ -50,6 +50,7 @@ export function configure (agent, opts = {}, loaderType, forceDrain) {
       internalTrafficList.push(updatedInit.proxy.assets)
     }
     if (updatedInit.proxy.beacon) internalTrafficList.push(updatedInit.proxy.beacon)
+    agent.beacons = [...internalTrafficList]
 
     setTopLevelCallers(agent) // no need to set global APIs on newrelic obj more than once
     addToNREUM('activatedFeatures', activatedFeatures)