@newrelic/browser-agent 1.298.0-rc.4 → 1.298.0-rc.5

package/dist/types/features/generic_events/aggregate/user-actions/aggregated-user-action.d.ts

@@ -1,5 +1,5 @@
 export class AggregatedUserAction {
-    constructor(evt: any, selectorPath: any, nearestTargetFields: any);
+    constructor(evt: any, selectorInfo: any);
     event: any;
     count: number;
     originMs: number;
@@ -8,6 +8,8 @@ export class AggregatedUserAction {
     rageClick: boolean | undefined;
     nearestTargetFields: any;
     currentUrl: string;
+    deadClick: boolean;
+    errorClick: boolean;
     /**
      * Aggregates the count and maintains the relative MS array for matching events
      * Will determine if a rage click was observed as part of the aggregation

package/dist/types/features/generic_events/aggregate/user-actions/aggregated-user-action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregated-user-action.d.ts","sourceRoot":"","sources":["../../../../../../src/features/generic_events/aggregate/user-actions/aggregated-user-action.js"],"names":[],"mappings":"AAOA;IACE,mEASC;IARC,WAAgB;IAChB,cAAc;IACd,iBAAyC;IACzC,qBAAqB;IACrB,kBAAgC;IAChC,+BAA0B;IAC1B,yBAA8C;IAC9C,mBAAyC;IAG3C;;;;;OAKG;IACH,eAHW,KAAK,GACH,IAAI,CAMhB;IAED;;;OAGG;IACH,eAFa,OAAO,CAKnB;CACF"}
+{"version":3,"file":"aggregated-user-action.d.ts","sourceRoot":"","sources":["../../../../../../src/features/generic_events/aggregate/user-actions/aggregated-user-action.js"],"names":[],"mappings":"AAOA;IACE,yCAWC;IAVC,WAAgB;IAChB,cAAc;IACd,iBAAyC;IACzC,qBAAqB;IACrB,kBAAqC;IACrC,+BAA0B;IAC1B,yBAAqD;IACrD,mBAAyC;IACzC,mBAAsB;IACtB,oBAAuB;IAGzB;;;;;OAKG;IACH,eAHW,KAAK,GACH,IAAI,CAMhB;IAED;;;OAGG;IACH,eAFa,OAAO,CAKnB;CACF"}

package/dist/types/features/generic_events/aggregate/user-actions/user-actions-aggregator.d.ts

@@ -1,4 +1,5 @@
 export class UserActionsAggregator {
+    constructor(userFrustrationsEnabled: any);
     get aggregationEvent(): AggregatedUserAction | undefined;
     /**
      * Process the event and determine if a new aggregation set should be made or if it should increment the current aggregation
@@ -6,6 +7,8 @@ export class UserActionsAggregator {
      * @returns {AggregatedUserAction|undefined} The previous aggregation set if it has been completed by processing the current event
      */
     process(evt: Event, targetFields: any): AggregatedUserAction | undefined;
+    markAsErrorClick(): void;
+    isLiveClick(): void;
     #private;
 }
 import { AggregatedUserAction } from './aggregated-user-action';

package/dist/types/features/generic_events/aggregate/user-actions/user-actions-aggregator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-actions-aggregator.d.ts","sourceRoot":"","sources":["../../../../../../src/features/generic_events/aggregate/user-actions/user-actions-aggregator.js"],"names":[],"mappings":"AAQA;IAKE,yDAQC;IAED;;;;OAIG;IACH,aAHW,KAAK,sBACH,oBAAoB,GAAC,SAAS,CAiB1C;;CACF;qCAtCoC,0BAA0B"}
+{"version":3,"file":"user-actions-aggregator.d.ts","sourceRoot":"","sources":["../../../../../../src/features/generic_events/aggregate/user-actions/user-actions-aggregator.js"],"names":[],"mappings":"AAUA;IASE,0CAKC;IAED,yDAQC;IAED;;;;OAIG;IACH,aAHW,KAAK,sBACH,oBAAoB,GAAC,SAAS,CA6B1C;IAED,yBAKC;IA0CD,oBAEC;;CACF;qCAlHoC,0BAA0B"}

package/dist/types/features/generic_events/constants.d.ts

@@ -3,6 +3,7 @@ export const OBSERVED_EVENTS: string[];
 export const OBSERVED_WINDOW_EVENTS: string[];
 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: string[];
 export namespace FEATURE_FLAGS {
     let MARKS: string;

package/dist/types/features/generic_events/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/generic_events/constants.js"],"names":[],"mappings":"AAMA,kCAAuD;AAEvD,uCAA6F;AAC7F,8CAAuD;AAEvD,0CAA2C,CAAC,CAAA;AAC5C,sCAAuC,IAAI,CAAA;AAE3C,4CAAsF"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/generic_events/constants.js"],"names":[],"mappings":"AAMA,kCAAuD;AAEvD,uCAA6F;AAC7F,8CAAuD;AAEvD,0CAA2C,CAAC,CAAA;AAC5C,sCAAuC,IAAI,CAAA;AAE3C,qCAAsC,IAAI,CAAA;AAE1C,4CAAsF"}

package/dist/types/features/generic_events/instrument/index.d.ts

@@ -1,6 +1,8 @@
 export class Instrument extends InstrumentBase {
     static featureName: string;
     constructor(agentRef: any);
+    removeOnAbort: AbortController | undefined;
+    abortHandler: () => void;
 }
 export const GenericEvents: typeof Instrument;
 import { InstrumentBase } from '../../utils/instrument-base';

package/dist/types/features/generic_events/instrument/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/instrument/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IACjC,2BA2CC;CACF;AAED,8CAAuC;+BAnDR,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/instrument/index.js"],"names":[],"mappings":"AAuBA;IACE,2BAAiC;IACjC,2BAuFC;IArCG,2CAA0C;IAG5C,yBAGC;CAgCJ;AAED,8CAAuC;+BArGR,6BAA6B"}

package/dist/types/loaders/api/noticeError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noticeError.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/noticeError.js"],"names":[],"mappings":"AAUA,sDAEC;AAED,6HAGC"}
+{"version":3,"file":"noticeError.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/noticeError.js"],"names":[],"mappings":"AAUA,sDAEC;AAED,6HAIC"}

package/dist/types/loaders/configure/configure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/configure.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,oGA6DC"}
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/configure.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,oGA8DC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.298.0-rc.4",
+  "version": "1.298.0-rc.5",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",

package/src/common/dom/selector-path.js

@@ -4,57 +4,69 @@
  */
 
 /**
- * Generates a CSS selector path for the given element, if possible
+ * Generates a CSS selector path for the given element, if possible.
+ * Also gather metadata about the element's nearest fields, and whether there are any links or buttons in the path.
+ *
+ * Starts with simple cases like window or document and progresses to more complex dom-tree traversals as needed.
+ * Will return path: undefined if no other path can be determined.
+ *
  * @param {HTMLElement} elem
- * @param {boolean} includeId
- * @param {boolean} includeClass
- * @returns {string|undefined}
+ * @param {Array<string>} [targetFields=[]] specifies which fields to gather from the nearest element in the path
+ * @returns {{path: (undefined|string), nearestFields: {}, hasButton: boolean, hasLink: boolean}}
  */
-export const generateSelectorPath = (elem, targetFields = []) => {
-  if (!elem) return { path: undefined, nearestFields: {} }
-
-  const getNthOfTypeIndex = (node) => {
-    try {
-      let i = 1
-      const { tagName } = node
-      while (node.previousElementSibling) {
-        if (node.previousElementSibling.tagName === tagName) i++
-        node = node.previousElementSibling
-      }
-      return i
-    } catch (err) {
-    // do nothing for now.  An invalid child count will make the path selector not return a nth-of-type selector statement
-    }
-  }
+export const analyzeElemPath = (elem, targetFields = []) => {
+  const result = { path: undefined, nearestFields: {}, hasButton: false, hasLink: false }
+  if (!elem) return result
+  if (elem === window) { result.path = 'window'; return result }
+  if (elem === document) { result.path = 'document'; return result }
 
   let pathSelector = ''
-  let index = getNthOfTypeIndex(elem)
+  const index = getNthOfTypeIndex(elem)
 
-  const nearestFields = {}
   try {
     while (elem?.tagName) {
-      const { id, localName } = elem
-      targetFields.forEach(field => { nearestFields[nearestAttrName(field)] ||= (elem[field]?.baseVal || elem[field]) })
-      const selector = [
-        localName,
-        id ? `#${id}` : '',
-        pathSelector ? `>${pathSelector}` : ''
-      ].join('')
-
-      pathSelector = selector
+      const tagName = elem.tagName.toLowerCase()
+      result.hasLink ||= tagName === 'a'
+      result.hasButton ||= tagName === 'button' || (tagName === 'input' && elem.type.toLowerCase() === 'button')
+
+      targetFields.forEach(field => { result.nearestFields[nearestAttrName(field)] ||= (elem[field]?.baseVal || elem[field]) })
+      pathSelector = buildPathSelector(elem, pathSelector)
       elem = elem.parentNode
     }
   } catch (err) {
-  // do nothing for now
+    // do nothing for now
   }
 
-  const path = pathSelector ? index ? `${pathSelector}:nth-of-type(${index})` : pathSelector : undefined
-  return { path, nearestFields }
+  result.path = pathSelector ? index ? `${pathSelector}:nth-of-type(${index})` : pathSelector : undefined
+  return result
+}
+
+function buildPathSelector (elem, pathSelector) {
+  const { id, localName } = elem
+  return [
+    localName,
+    id ? `#${id}` : '',
+    pathSelector ? `>${pathSelector}` : ''
+  ].join('')
+}
 
-  function nearestAttrName (originalFieldName) {
-    /** preserve original renaming structure for pre-existing field maps */
-    if (originalFieldName === 'tagName') originalFieldName = 'tag'
-    if (originalFieldName === 'className') originalFieldName = 'class'
-    return `nearest${originalFieldName.charAt(0).toUpperCase() + originalFieldName.slice(1)}`
+function getNthOfTypeIndex (node) {
+  try {
+    let i = 1
+    const { tagName } = node
+    while (node.previousElementSibling) {
+      if (node.previousElementSibling.tagName === tagName) i++
+      node = node.previousElementSibling
+    }
+    return i
+  } catch (err) {
+    // do nothing for now.  An invalid child count will make the path selector not return a nth-of-type selector statement
   }
 }
+
+function nearestAttrName (originalFieldName) {
+  /** preserve original renaming structure for pre-existing field maps */
+  if (originalFieldName === 'tagName') originalFieldName = 'tag'
+  if (originalFieldName === 'className') originalFieldName = 'class'
+  return `nearest${originalFieldName.charAt(0).toUpperCase() + originalFieldName.slice(1)}`
+}

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/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)