@newrelic/browser-agent 1.298.0 → 1.299.0-rc.1

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.299.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.298.0...v1.299.0) (2025-10-07)
+
+
+### Features
+
+* Add Flutter supportability metric ([#1580](https://github.com/newrelic/newrelic-browser-agent/issues/1580)) ([5083067](https://github.com/newrelic/newrelic-browser-agent/commit/5083067e1dab2fed972af8010d95c07ba11ec436))
+* Add user frustration signals to UserAction ([#1534](https://github.com/newrelic/newrelic-browser-agent/issues/1534)) ([4d654c3](https://github.com/newrelic/newrelic-browser-agent/commit/4d654c3e4cef906885545b36142fc03da34d525c))
+* Evaluate the accuracy of cross-feature attribution ([#1573](https://github.com/newrelic/newrelic-browser-agent/issues/1573)) ([b1e03e2](https://github.com/newrelic/newrelic-browser-agent/commit/b1e03e216ec4eedb77cbb49241d51b5526b97997))
+
+
+### Bug Fixes
+
+* Fix recordReplay API inconsistencies ([#1582](https://github.com/newrelic/newrelic-browser-agent/issues/1582)) ([e4465c1](https://github.com/newrelic/newrelic-browser-agent/commit/e4465c1ebfd6f50d3fce99074ae190ce3bc2f4e4))
+
 ## [1.298.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.297.1...v1.298.0) (2025-09-19)
 
 

package/README.md

@@ -389,9 +389,19 @@ A lot of new frameworks support the concept of server-side rendering the pages o
 
 ## Support
 
-New Relic hosts and moderates an online forum where customers can interact with New Relic employees as well as other customers to get help and share best practices. Like all official New Relic open source projects, there's a related Community topic in the New Relic Explorers Hub. You can find this project's topic/threads here:
+Should you need assistance with New Relic products, you are in good hands with several support channels.
 
-https://discuss.newrelic.com/c/full-stack-observability/browser
+If the issue has been confirmed as a bug or is a feature request, please file a GitHub issue.
+
+### Support Channels
+
+- [New Relic Documentation](https://docs.newrelic.com/docs/browser/browser-monitoring/getting-started/introduction-browser-monitoring/): Comprehensive guidance for using our platform
+
+- [New Relic Community](https://support.newrelic.com/s/category/Category__c/Default): The best place to engage in troubleshooting questions
+
+- [New Relic University](https://learn.newrelic.com/): A range of online training for New Relic users of every level
+
+- [New Relic Technical Support](https://support.newrelic.com/s/#): 24/7/365 ticketed support. Read more about our [Technical Support Offerings](https://docs.newrelic.com/docs/licenses/license-information/general-usage-licenses/global-technical-support-offerings/).
 
 ## Contribute
 

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

@@ -17,7 +17,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.298.0";
+const VERSION = exports.VERSION = "1.299.0-rc.1";
 
 /**
  * Exposes the build type of the agent

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

@@ -17,7 +17,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.298.0";
+const VERSION = exports.VERSION = "1.299.0-rc.1";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/dom/selector-path.js

@@ -3,68 +3,84 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.generateSelectorPath = void 0;
+exports.analyzeElemPath = void 0;
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
 /**
- * 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}}
  */
-const generateSelectorPath = (elem, targetFields = []) => {
-  if (!elem) return {
+const analyzeElemPath = (elem, targetFields = []) => {
+  const result = {
     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
-    }
+    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 nearestFields = {};
+  const index = getNthOfTypeIndex(elem);
   try {
     while (elem?.tagName) {
-      const {
-        id,
-        localName
-      } = elem;
+      const tagName = elem.tagName.toLowerCase();
+      result.hasLink ||= tagName === 'a';
+      result.hasButton ||= tagName === 'button' || tagName === 'input' && elem.type.toLowerCase() === 'button';
       targetFields.forEach(field => {
-        nearestFields[nearestAttrName(field)] ||= elem[field]?.baseVal || elem[field];
+        result.nearestFields[nearestAttrName(field)] ||= elem[field]?.baseVal || elem[field];
       });
-      const selector = [localName, id ? "#".concat(id) : '', pathSelector ? ">".concat(pathSelector) : ''].join('');
-      pathSelector = selector;
+      pathSelector = buildPathSelector(elem, pathSelector);
       elem = elem.parentNode;
     }
   } catch (err) {
     // do nothing for now
   }
-  const path = pathSelector ? index ? "".concat(pathSelector, ":nth-of-type(").concat(index, ")") : pathSelector : undefined;
-  return {
-    path,
-    nearestFields
-  };
-  function nearestAttrName(originalFieldName) {
-    /** preserve original renaming structure for pre-existing field maps */
-    if (originalFieldName === 'tagName') originalFieldName = 'tag';
-    if (originalFieldName === 'className') originalFieldName = 'class';
-    return "nearest".concat(originalFieldName.charAt(0).toUpperCase() + originalFieldName.slice(1));
-  }
+  result.path = pathSelector ? index ? "".concat(pathSelector, ":nth-of-type(").concat(index, ")") : pathSelector : undefined;
+  return result;
 };
-exports.generateSelectorPath = generateSelectorPath;
+exports.analyzeElemPath = analyzeElemPath;
+function buildPathSelector(elem, pathSelector) {
+  const {
+    id,
+    localName
+  } = elem;
+  return [localName, id ? "#".concat(id) : '', pathSelector ? ">".concat(pathSelector) : ''].join('');
+}
+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".concat(originalFieldName.charAt(0).toUpperCase() + originalFieldName.slice(1));
+}

package/dist/cjs/common/harvest/harvester.js

@@ -153,14 +153,16 @@ function send(agentRef, {
   }
   const fullUrl = "".concat(url, "?").concat(baseParams).concat(payloadParams);
   const gzip = !!qs?.attributes?.includes('gzip');
-  if (!gzip) {
-    if (endpoint !== _features.EVENTS) body = (0, _stringify.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) (0, _console.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 === _features.EVENTS ? body : (0, _stringify.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 !== _features.BLOBS && stringBody.length > 750000 && (warnings[endpoint] = (warnings[endpoint] || 0) + 1) === 1) (0, _console.warn)(28, endpoint);
   const headers = [{
     key: 'content-type',
     value: 'text/plain'
@@ -172,7 +174,7 @@ function send(agentRef, {
      Following the removal of img-element method. */
   let result = submitMethod({
     url: fullUrl,
-    body,
+    body: stringBody,
     sync: localOpts.isFinalHarvest && _runtime.isWorkerScope,
     headers
   });
@@ -192,6 +194,9 @@ function send(agentRef, {
         };
         if (localOpts.needResponse) cbResult.responseText = this.responseText;
         cbFinished(cbResult);
+
+        /** temporary audit of consistency of harvest metadata flags */
+        if (!shouldRetry(this.status)) trackHarvestMetadata();
       }, (0, _eventListenerOpts.eventListenerOpts)(false));
     } else if (submitMethod === _submitData.xhrFetch) {
       result.then(async function (response) {
@@ -206,8 +211,33 @@ function send(agentRef, {
         };
         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 === _features.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');
+        (0, _handle.handle)('harvest-metadata', [{
+          [featureName]: {
+            ...(hasReplay && {
+              hasReplay
+            }),
+            ...(hasTrace && {
+              hasTrace
+            }),
+            ...(hasError && {
+              hasError
+            })
+          }
+        }], undefined, _features.FEATURE_NAMES.metrics, agentRef.ee);
+      } catch (err) {
+        // do nothing
+      }
+    }
   }
   (0, _globalEvent.dispatchGlobalEvent)({
     agentIdentifier: agentRef.agentIdentifier,

package/dist/cjs/common/url/extract-url.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractUrl = extractUrl;
+var _runtime = require("../constants/runtime");
+var _nreum = require("../window/nreum");
+/**
+ * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * 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.
+ */
+function extractUrl(target) {
+  if (typeof target === 'string') return target;else if (target instanceof (0, _nreum.gosNREUMOriginals)().o.REQ) return target.url;else if (_runtime.globalScope?.URL && target instanceof URL) return target.href;
+}

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

@@ -21,6 +21,7 @@ var _features = require("../../../loaders/features/features");
 var _constants2 = require("../../metrics/constants");
 var _now = require("../../../common/timing/now");
 var _denyList = require("../../../common/deny-list/deny-list");
+var _extractUrl = require("../../../common/url/extract-url");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; } /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
@@ -298,15 +299,7 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
     if (fetchArguments.length >= 2) this.opts = fetchArguments[1];
     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 (_runtime.globalScope?.URL && typeof target === 'object' && target instanceof URL) {
-      url = target.href;
-    }
-    addUrl(this, url);
+    addUrl(this, (0, _extractUrl.extractUrl)(target));
     var method = ('' + (target && target instanceof origRequest && target.method || opts.method || 'GET')).toUpperCase();
     this.params.method = method;
     this.body = opts.body;

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

@@ -23,6 +23,7 @@ var _typeCheck = require("../../../common/util/type-check");
 
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
+  #userActionAggregator;
   constructor(agentRef) {
     super(agentRef, _constants.FEATURE_NAME);
     this.referrerUrl = _runtime.isBrowserScope && document.referrer ? (0, _cleanUrl.cleanURL)(document.referrer) : undefined;
@@ -32,7 +33,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         this.deregisterDrain();
         return;
       }
-      this.trackSupportabilityMetrics();
+      this.#trackSupportabilityMetrics();
       (0, _registerHandler.registerHandler)('api-recordCustomEvent', (timestamp, eventType, attributes) => {
         if (_constants.RESERVED_EVENT_TYPES.includes(eventType)) return (0, _console.warn)(46);
         this.addEvent({
@@ -60,8 +61,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
       }
       let addUserAction = () => {/** no-op */};
       if (_runtime.isBrowserScope && agentRef.init.user_actions.enabled) {
-        this.userActionAggregator = new _userActionsAggregator.UserActionsAggregator();
-        this.harvestOpts.beforeUnload = () => addUserAction?.(this.userActionAggregator.aggregationEvent);
+        this.#userActionAggregator = new _userActionsAggregator.UserActionsAggregator(agentRef.init.feature_flags.includes('user_frustrations'));
+        this.harvestOpts.beforeUnload = () => addUserAction?.(this.#userActionAggregator.aggregationEvent);
         addUserAction = aggregatedUserAction => {
           try {
             /** The aggregator process only returns an event when it is "done" aggregating -
@@ -72,7 +73,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
                 timeStamp,
                 type
               } = aggregatedUserAction.event;
-              this.addEvent({
+              const userActionEvent = {
                 eventType: 'UserAction',
                 timestamp: this.toEpoch(timeStamp),
                 action: type,
@@ -90,8 +91,16 @@ class Aggregate extends _aggregateBase.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
@@ -121,8 +130,15 @@ class Aggregate extends _aggregateBase.AggregateBase {
         };
         (0, _registerHandler.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);
+        (0, _registerHandler.registerHandler)('navChange', () => {
+          this.#userActionAggregator.isLiveClick();
         }, this.featureName, this.ee);
+        (0, _registerHandler.registerHandler)('uaXhr', () => {
+          this.#userActionAggregator.isLiveClick();
+        }, this.featureName, this.ee);
+        (0, _registerHandler.registerHandler)('uaErr', () => this.#userActionAggregator.markAsErrorClick(), this.featureName, this.ee);
       }
 
       /**
@@ -298,7 +314,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
   toEpoch(timestamp) {
     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');
@@ -308,5 +324,10 @@ class Aggregate extends _aggregateBase.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');
+  }
 }
 exports.Aggregate = Aggregate;

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

@@ -12,15 +12,17 @@ var _cleanUrl = require("../../../../common/url/clean-url");
  */
 
 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 = (0, _cleanUrl.cleanURL)('' + location);
+    this.deadClick = false;
+    this.errorClick = false;
   }
 
   /**

package/dist/cjs/features/generic_events/aggregate/user-actions/user-actions-aggregator.js

@@ -7,6 +7,8 @@ exports.UserActionsAggregator = void 0;
 var _selectorPath = require("../../../../common/dom/selector-path");
 var _constants = require("../../constants");
 var _aggregatedUserAction = require("./aggregated-user-action");
+var _timer = require("../../../../common/timer/timer");
+var _nreum = require("../../../../common/window/nreum");
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -16,6 +18,16 @@ class UserActionsAggregator {
   /** @type {AggregatedUserAction=} */
   #aggregationEvent = undefined;
   #aggregationKey = '';
+  #ufEnabled = false;
+  #deadClickTimer = undefined;
+  #domObserver = undefined;
+  #errorClickTimer = undefined;
+  constructor(userFrustrationsEnabled) {
+    if (userFrustrationsEnabled && (0, _nreum.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
     // to prevent potential mutability and duplication issues, so the state is cleared upon returning.
@@ -33,50 +45,75 @@ class UserActionsAggregator {
    */
   process(evt, targetFields) {
     if (!evt) return;
-    const {
-      selectorPath,
-      nearestTargetFields
-    } = getSelectorPath(evt, targetFields);
-    const aggregationKey = getAggregationKey(evt, selectorPath);
+    const targetElem = _constants.OBSERVED_WINDOW_EVENTS.includes(evt.type) ? window : evt.target;
+    const selectorInfo = (0, _selectorPath.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.AggregatedUserAction(evt, selectorPath, nearestTargetFields);
+      this.#aggregationEvent = new _aggregatedUserAction.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}
- */
-exports.UserActionsAggregator = UserActionsAggregator;
-function getSelectorPath(evt, targetFields) {
-  let selectorPath;
-  let nearestTargetFields = {};
-  if (_constants.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
-    } = (0, _selectorPath.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.Timer({
+      onEnd: () => {
+        this.#errorClickCleanup();
+      }
+    }, _constants.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.Timer({
+      onEnd: () => {
+        userAction.deadClick = true;
+        this.#deadClickCleanup();
+      }
+    }, _constants.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
-  };
 }
 
 /**
@@ -86,6 +123,7 @@ function getSelectorPath(evt, targetFields) {
  * @param {string} selectorPath
  * @returns {string}
  */
+exports.UserActionsAggregator = UserActionsAggregator;
 function getAggregationKey(evt, selectorPath) {
   let aggregationKey = evt.type;
   /** aggregate all scrollends into one set (if sequential), no matter what their target is

package/dist/cjs/features/generic_events/constants.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.RESERVED_EVENT_TYPES = exports.RAGE_CLICK_THRESHOLD_MS = exports.RAGE_CLICK_THRESHOLD_EVENTS = exports.OBSERVED_WINDOW_EVENTS = exports.OBSERVED_EVENTS = exports.FEATURE_NAME = exports.FEATURE_FLAGS = void 0;
+exports.RESERVED_EVENT_TYPES = exports.RAGE_CLICK_THRESHOLD_MS = exports.RAGE_CLICK_THRESHOLD_EVENTS = exports.OBSERVED_WINDOW_EVENTS = exports.OBSERVED_EVENTS = exports.FRUSTRATION_TIMEOUT_MS = exports.FEATURE_NAME = exports.FEATURE_FLAGS = void 0;
 var _features = require("../../loaders/features/features");
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
@@ -15,6 +15,7 @@ const OBSERVED_EVENTS = exports.OBSERVED_EVENTS = ['auxclick', 'click', 'copy',
 const OBSERVED_WINDOW_EVENTS = exports.OBSERVED_WINDOW_EVENTS = ['focus', 'blur'];
 const RAGE_CLICK_THRESHOLD_EVENTS = exports.RAGE_CLICK_THRESHOLD_EVENTS = 4;
 const RAGE_CLICK_THRESHOLD_MS = exports.RAGE_CLICK_THRESHOLD_MS = 1000;
+const FRUSTRATION_TIMEOUT_MS = exports.FRUSTRATION_TIMEOUT_MS = 2000;
 const RESERVED_EVENT_TYPES = exports.RESERVED_EVENT_TYPES = ['PageAction', 'UserAction', 'BrowserPerformance'];
 const FEATURE_FLAGS = exports.FEATURE_FLAGS = {
   MARKS: 'experimental.marks',

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

@@ -15,6 +15,12 @@ var _register = require("../../../loaders/api/register");
 var _measure = require("../../../loaders/api/measure");
 var _instrumentBase = require("../../utils/instrument-base");
 var _constants = require("../constants");
+var _features = require("../../../loaders/features/features");
+var _wrapHistory = require("../../../common/wrap/wrap-history");
+var _wrapFetch = require("../../../common/wrap/wrap-fetch");
+var _wrapXhr = require("../../../common/wrap/wrap-xhr");
+var _parseUrl = require("../../../common/url/parse-url");
+var _extractUrl = require("../../../common/url/extract-url");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; } /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
@@ -58,6 +64,45 @@ class Instrument extends _instrumentBase.InstrumentBase {
           buffered: true
         });
       }
+      const historyEE = (0, _wrapHistory.wrapHistory)(this.ee);
+      historyEE.on('pushState-end', navigationChange);
+      historyEE.on('replaceState-end', navigationChange);
+      window.addEventListener('hashchange', navigationChange, (0, _eventListenerOpts.eventListenerOpts)(true, this.removeOnAbort?.signal));
+      window.addEventListener('popstate', navigationChange, (0, _eventListenerOpts.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
+    };
+    _runtime.globalScope.addEventListener('error', () => {
+      (0, _handle.handle)('uaErr', [], undefined, _features.FEATURE_NAMES.genericEvents, this.ee);
+    }, (0, _eventListenerOpts.eventListenerOpts)(false, this.removeOnAbort?.signal));
+    (0, _wrapFetch.wrapFetch)(this.ee);
+    (0, _wrapXhr.wrapXhr)(this.ee);
+    this.ee.on('open-xhr-start', (args, xhr) => {
+      if (!isInternalTraffic(args[1])) {
+        xhr.addEventListener('readystatechange', () => {
+          if (xhr.readyState === 2) {
+            // HEADERS_RECEIVED
+            (0, _handle.handle)('uaXhr', [], undefined, _features.FEATURE_NAMES.genericEvents, this.ee);
+          }
+        });
+      }
+    });
+    this.ee.on('fetch-start', fetchArguments => {
+      if (fetchArguments.length >= 1 && !isInternalTraffic((0, _extractUrl.extractUrl)(fetchArguments[0]))) {
+        (0, _handle.handle)('uaXhr', [], undefined, _features.FEATURE_NAMES.genericEvents, this.ee);
+      }
+    });
+    function isInternalTraffic(url) {
+      const parsedUrl = (0, _parseUrl.parseUrl)(url);
+      return agentRef.beacons.includes(parsedUrl.hostname + ':' + parsedUrl.port);
     }
 
     /** If any of the sources are active, import the aggregator. otherwise deregister */