@newrelic/browser-agent 1.298.0 → 1.299.0

package/dist/cjs/features/metrics/aggregate/framework-detection.js

@@ -29,6 +29,7 @@ const FRAMEWORKS = {
   JQUERY: 'Jquery',
   MOOTOOLS: 'MooTools',
   QWIK: 'Qwik',
+  FLUTTER: 'Flutter',
   ELECTRON: 'Electron'
 };
 function getFrameworks() {
@@ -64,6 +65,7 @@ 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) {
     // Possibly not supported

package/dist/cjs/features/metrics/aggregate/harvest-metadata.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evaluateHarvestMetadata = evaluateHarvestMetadata;
+/**
+ * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+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/dist/cjs/features/metrics/aggregate/index.js

@@ -13,6 +13,7 @@ var _eventListenerOpts = require("../../../common/event-listener/event-listener-
 var _runtime = require("../../../common/constants/runtime");
 var _aggregateBase = require("../../utils/aggregate-base");
 var _iframe = require("../../../common/dom/iframe");
+var _harvestMetadata = require("./harvest-metadata");
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -26,6 +27,15 @@ class Aggregate extends _aggregateBase.AggregateBase {
   constructor(agentRef) {
     super(agentRef, _constants.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 = () => {
+      (0, _harvestMetadata.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
@@ -145,6 +155,17 @@ class Aggregate extends _aggregateBase.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 */
+    (0, _registerHandler.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() {
     if (!_runtime.isBrowserScope) return;

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

@@ -142,7 +142,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         sessionReplayMode: this.mode
       });
     } else {
-      this.initializeRecording(_constants2.MODE.FULL, true);
+      this.initializeRecording(_constants2.MODE.FULL, true, _constants.TRIGGERS.SWITCH_TO_FULL);
     }
   }
 

package/dist/cjs/features/session_replay/shared/recorder.js

@@ -59,9 +59,13 @@ class Recorder {
       this.#canRecord = false;
       this.stopRecording();
     }, this.srFeatureName, this.ee);
-    (0, _registerHandler.registerHandler)(RRWEB_DATA_CHANNEL, (event, isCheckout) => {
+
+    /** 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);
-    }, this.srFeatureName, this.ee);
+    };
+    if (this.srInstrument.featAggregate?.drained) this.ee.on(RRWEB_DATA_CHANNEL, processReplayNode);else (0, _registerHandler.registerHandler)(RRWEB_DATA_CHANNEL, processReplayNode, this.srFeatureName, this.ee);
   }
   get trigger() {
     return this.triggerHistory[this.triggerHistory.length - 1];

package/dist/cjs/loaders/api/noticeError.js

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

package/dist/cjs/loaders/configure/configure.js

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

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.298.0";
+export const VERSION = "1.299.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.298.0";
+export const VERSION = "1.299.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -4,60 +4,76 @@
  */
 
 /**
- * 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 {
+export 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;
+};
+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/esm/common/harvest/harvester.js

@@ -145,14 +145,16 @@ export function send(agentRef, {
   }
   const fullUrl = "".concat(url, "?").concat(baseParams).concat(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'
@@ -164,7 +166,7 @@ export function send(agentRef, {
      Following the removal of img-element method. */
   let result = submitMethod({
     url: fullUrl,
-    body,
+    body: stringBody,
     sync: localOpts.isFinalHarvest && isWorkerScope,
     headers
   });
@@ -184,6 +186,9 @@ export 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();
       }, eventListenerOpts(false));
     } else if (submitMethod === fetchMethod) {
       result.then(async function (response) {
@@ -198,8 +203,33 @@ export 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 === 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({
     agentIdentifier: agentRef.agentIdentifier,

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

@@ -0,0 +1,15 @@
+/**
+ * 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/dist/esm/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;
 var origRequest = gosNREUMOriginals().o.REQ;
@@ -290,15 +291,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 (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();
     this.params.method = method;
     this.body = opts.body;

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

@@ -16,6 +16,7 @@ import { isIFrameWindow } from '../../../common/dom/iframe';
 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;
@@ -25,7 +26,7 @@ export class Aggregate extends AggregateBase {
         this.deregisterDrain();
         return;
       }
-      this.trackSupportabilityMetrics();
+      this.#trackSupportabilityMetrics();
       registerHandler('api-recordCustomEvent', (timestamp, eventType, attributes) => {
         if (RESERVED_EVENT_TYPES.includes(eventType)) return warn(46);
         this.addEvent({
@@ -53,8 +54,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 {
             /** The aggregator process only returns an event when it is "done" aggregating -
@@ -65,7 +66,7 @@ export class Aggregate extends AggregateBase {
                 timeStamp,
                 type
               } = aggregatedUserAction.event;
-              this.addEvent({
+              const userActionEvent = {
                 eventType: 'UserAction',
                 timestamp: this.toEpoch(timeStamp),
                 action: type,
@@ -83,8 +84,16 @@ 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
@@ -114,8 +123,15 @@ 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);
       }
 
       /**
@@ -291,7 +307,7 @@ export class Aggregate extends 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');
@@ -301,4 +317,9 @@ 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/dist/esm/features/generic_events/aggregate/user-actions/aggregated-user-action.js

@@ -5,15 +5,17 @@
 import { RAGE_CLICK_THRESHOLD_EVENTS, RAGE_CLICK_THRESHOLD_MS } from '../../constants';
 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/dist/esm/features/generic_events/aggregate/user-actions/user-actions-aggregator.js

@@ -2,13 +2,25 @@
  * 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
     // to prevent potential mutability and duplication issues, so the state is cleared upon returning.
@@ -26,49 +38,75 @@ 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
-  };
 }
 
 /**