@newrelic/browser-agent 1.266.0 → 1.268.0

package/CHANGELOG.md

@@ -3,6 +3,35 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.268.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.267.0...v1.268.0) (2024-10-08)
+
+
+### Features
+
+* Add UserAction to GenericEvents ([#1186](https://github.com/newrelic/newrelic-browser-agent/issues/1186)) ([1b0bb1d](https://github.com/newrelic/newrelic-browser-agent/commit/1b0bb1dd992674f77c41a73449b64b022cdfc83c))
+* Aggregate UserActions ([#1195](https://github.com/newrelic/newrelic-browser-agent/issues/1195)) ([b5e4c6d](https://github.com/newrelic/newrelic-browser-agent/commit/b5e4c6dcdcfce3ab88132f2a1d82d4d02ab7640b))
+
+
+### Bug Fixes
+
+* Always return a string for custom stringify method ([#1207](https://github.com/newrelic/newrelic-browser-agent/issues/1207)) ([94a9a0b](https://github.com/newrelic/newrelic-browser-agent/commit/94a9a0b465e9ea34132317236d47ac9f62ee4051))
+* Force generic events feature to clear buffer when unloading ([#1202](https://github.com/newrelic/newrelic-browser-agent/issues/1202)) ([d3fac07](https://github.com/newrelic/newrelic-browser-agent/commit/d3fac07379d18c98e9838152a31a482ff25fe5bf))
+
+## [1.267.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.266.0...v1.267.0) (2024-09-23)
+
+
+### Features
+
+* add soft navigations to Browser-Agent loader ([#1191](https://github.com/newrelic/newrelic-browser-agent/issues/1191)) ([fd033a7](https://github.com/newrelic/newrelic-browser-agent/commit/fd033a7be52fed01e5a67a5f8060cf6ec080c769))
+* Improve notifications of stylesheet status for session replay ([#1190](https://github.com/newrelic/newrelic-browser-agent/issues/1190)) ([a21b939](https://github.com/newrelic/newrelic-browser-agent/commit/a21b939884697fc4951e6d4cdaceecaa9b000810))
+* Update TimeKeeper Source of Truth ([#1181](https://github.com/newrelic/newrelic-browser-agent/issues/1181)) ([60d63cf](https://github.com/newrelic/newrelic-browser-agent/commit/60d63cf416529d700abaa6fa36ba3e64402b35a9))
+* Upgrade to web-vitals v4 ([#1193](https://github.com/newrelic/newrelic-browser-agent/issues/1193)) ([81349b8](https://github.com/newrelic/newrelic-browser-agent/commit/81349b82f5befd88f425cce1dee06f08fcea8a05))
+
+### Bug Fixes
+
+* Improve reliability of customMasker ([#1197](https://github.com/newrelic/newrelic-browser-agent/issues/1197)) ([9f2ef1f](https://github.com/newrelic/newrelic-browser-agent/commit/9f2ef1f7d0e5dceaf61745a47849a3b2cc930c53))
+* Stringify now returns an empty string if failed to transform ([#1198](https://github.com/newrelic/newrelic-browser-agent/issues/1198)) ([310937a](https://github.com/newrelic/newrelic-browser-agent/commit/310937ae20a004f91f3ccb4ba6b1d1b230d92632))
+
 ## [1.266.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.265.1...v1.266.0) (2024-09-16)
 
 

package/dist/cjs/common/config/init.js

@@ -80,6 +80,9 @@ const model = () => {
     page_action: {
       enabled: true
     },
+    user_actions: {
+      enabled: true
+    },
     page_view_event: {
       enabled: true,
       autoStart: true
@@ -117,10 +120,8 @@ const model = () => {
       // serialize fonts for collection without public asset url, this is currently broken in RRWeb -- https://github.com/rrweb-io/rrweb/issues/1304.  When fixed, revisit with test cases
       inline_images: false,
       // serialize images for collection without public asset url -- right now this is only useful for testing as it easily generates payloads too large to be harvested
-      inline_stylesheet: true,
-      // serialize css for collection without public asset url
       fix_stylesheets: true,
-      // fetch missing stylesheet resources for inlining, only works if 'inline_stylesheet' is also true
+      // fetch missing stylesheet resources for inlining
       // recording config settings
       mask_all_inputs: true,
       // this has a getter/setter to facilitate validation of the selectors

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.266.0";
+const VERSION = exports.VERSION = "1.268.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.266.0";
+const VERSION = exports.VERSION = "1.268.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/dom/iframe.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIFrameWindow = isIFrameWindow;
+function isIFrameWindow(windowObject) {
+  if (!windowObject) return false;
+  return windowObject.self !== windowObject.top;
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateSelectorPath = void 0;
+/**
+ * Generates a CSS selector path for the given element, if possible
+ * @param {HTMLElement} elem
+ * @param {boolean} includeId
+ * @param {boolean} includeClass
+ * @returns {string|undefined}
+ */
+const generateSelectorPath = elem => {
+  if (!elem) return;
+  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
+    }
+  };
+  let pathSelector = '';
+  let index = getNthOfTypeIndex(elem);
+  try {
+    while (elem?.tagName) {
+      const {
+        id,
+        localName
+      } = elem;
+      const selector = [localName, id ? "#".concat(id) : '', pathSelector ? ">".concat(pathSelector) : ''].join('');
+      pathSelector = selector;
+      elem = elem.parentNode;
+    }
+  } catch (err) {
+    // do nothing for now
+  }
+  return pathSelector ? index ? "".concat(pathSelector, ":nth-of-type(").concat(index, ")") : pathSelector : undefined;
+};
+exports.generateSelectorPath = generateSelectorPath;

package/dist/cjs/common/event-listener/event-listener-opts.js

@@ -6,34 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.documentAddEventListener = documentAddEventListener;
 exports.eventListenerOpts = eventListenerOpts;
 exports.windowAddEventListener = windowAddEventListener;
-var _runtime = require("../constants/runtime");
-/*
- * See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#safely_detecting_option_support
- */
-let passiveSupported = false;
-let signalSupported = false;
-try {
-  const options = {
-    get passive() {
-      // this function will be called when the browser attempts to access the passive property
-      passiveSupported = true;
-      return false;
-    },
-    get signal() {
-      signalSupported = true;
-      return false;
-    }
-  };
-  _runtime.globalScope.addEventListener('test', null, options);
-  _runtime.globalScope.removeEventListener('test', null, options);
-} catch (err) {}
 function eventListenerOpts(useCapture, abortSignal) {
-  return passiveSupported || signalSupported ? {
-    capture: !!useCapture,
-    passive: passiveSupported,
-    // passive defaults to false
+  return {
+    capture: useCapture,
+    passive: false,
     signal: abortSignal
-  } : !!useCapture; // mainly just IE11 doesn't support third param options under EventTarget API
+  };
 }
 
 /** Do not use this within the worker context. */

package/dist/cjs/common/timing/time-keeper.js

@@ -6,8 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.TimeKeeper = void 0;
 var _runtime = require("../constants/runtime");
 var _runtime2 = require("../config/runtime");
-const rfc2616Regex = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), ([0-3][0-9]) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ([0-9]{4}) ([01][0-9]|2[0-3])(:[0-5][0-9]){2} GMT$/;
-
 /**
  * Class used to adjust the timestamp of harvested data to New Relic server time. This
  * is done by tracking the performance timings of the RUM call and applying a calculation
@@ -58,26 +56,21 @@ class TimeKeeper {
    * @param rumRequest {XMLHttpRequest} The xhr for the rum request
    * @param startTime {number} The start time of the RUM request
    * @param endTime {number} The end time of the RUM request
+   * @param nrServerTime {number} the unix number value of the NR server time in MS, returned in the RUM request body
    */
-  processRumRequest(rumRequest, startTime, endTime) {
+  processRumRequest(rumRequest, startTime, endTime, nrServerTime) {
     this.processStoredDiff(); // Check session entity for stored time diff
     if (this.#ready) return; // Server time calculated from session entity
 
-    const responseDateHeader = rumRequest.getResponseHeader('Date');
-    if (!responseDateHeader) {
-      throw new Error('Missing date header on rum response.');
-    }
-    if (!rfc2616Regex.test(responseDateHeader)) {
-      throw new Error('Date header invalid format.');
-    }
+    if (!nrServerTime) throw new Error('nrServerTime not found');
     const medianRumOffset = (endTime - startTime) / 2;
     const serverOffset = startTime + medianRumOffset;
 
     // Corrected page origin time
-    this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset);
+    this.#correctedOriginTime = Math.floor(nrServerTime - serverOffset);
     this.#localTimeDiff = _runtime.originTime - this.#correctedOriginTime;
     if (isNaN(this.#correctedOriginTime)) {
-      throw new Error('Date header invalid format.');
+      throw new Error('Failed to correct browser time to server time');
     }
     this.#session?.write({
       serverTimeDiff: this.#localTimeDiff
@@ -114,6 +107,15 @@ class TimeKeeper {
     return timestamp - this.#localTimeDiff;
   }
 
+  /**
+   * Corrects relative timestamp to NR server time (epoch).
+   * @param {DOMHighResTimeStamp} relativeTime
+   * @returns {number}
+   */
+  correctRelativeTimestamp(relativeTime) {
+    return this.correctAbsoluteTimestamp(this.convertRelativeTimestamp(relativeTime));
+  }
+
   /** Process the session entity and use the info to set the main time calculations if present */
   processStoredDiff() {
     if (this.#ready) return; // Time diff has already been calculated

package/dist/cjs/common/util/stringify.js

@@ -36,12 +36,14 @@ const getCircularReplacer = () => {
  */
 function stringify(val) {
   try {
-    return JSON.stringify(val, getCircularReplacer());
+    return JSON.stringify(val, getCircularReplacer()) ?? '';
   } catch (e) {
     try {
       _contextualEe.ee.emit('internal-error', [e]);
     } catch (err) {
       // do nothing
     }
+    // return a string so that downstream users of the method do not throw errors
+    return '';
   }
 }

package/dist/cjs/common/vitals/interaction-to-next-paint.js

@@ -18,9 +18,17 @@ if (_runtime.isBrowserScope) {
   }) => {
     const attrs = {
       metricId: id,
-      eventTarget: attribution.eventTarget,
-      eventType: attribution.eventType,
-      eventTime: attribution.eventTime,
+      eventTarget: attribution.interactionTarget,
+      // event* attrs deprecated in v4, kept for NR backwards compatibility
+      eventTime: attribution.interactionTime,
+      // event* attrs deprecated in v4, kept for NR backwards compatibility
+      interactionTarget: attribution.interactionTarget,
+      interactionTime: attribution.interactionTime,
+      interactionType: attribution.interactionType,
+      inputDelay: attribution.inputDelay,
+      nextPaintTime: attribution.nextPaintTime,
+      processingDuration: attribution.processingDuration,
+      presentationDelay: attribution.presentationDelay,
       loadState: attribution.loadState
     };
     interactionToNextPaint.update({

package/dist/cjs/common/vitals/largest-contentful-paint.js

@@ -26,7 +26,9 @@ if (_runtime.isBrowserScope) {
         element: attribution.element,
         timeToFirstByte: attribution.timeToFirstByte,
         resourceLoadDelay: attribution.resourceLoadDelay,
-        resourceLoadTime: attribution.resourceLoadTime,
+        resourceLoadDuration: attribution.resourceLoadDuration,
+        resourceLoadTime: attribution.resourceLoadDuration,
+        // kept for NR backwards compatibility, deprecated in v3->v4
         elementRenderDelay: attribution.elementRenderDelay
       };
       if (attribution.url) attrs.elUrl = (0, _cleanUrl.cleanURL)(attribution.url);

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

@@ -21,6 +21,8 @@ var _constants2 = require("../../metrics/constants");
 var _eventBuffer = require("../../utils/event-buffer");
 var _traverse = require("../../../common/util/traverse");
 var _agentConstants = require("../../../common/constants/agent-constants");
+var _userActionsAggregator = require("./user-actions/user-actions-aggregator");
+var _iframe = require("../../../common/dom/iframe");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -31,8 +33,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
+    const agentInit = (0, _init.getConfiguration)(this.agentIdentifier);
     this.eventsPerHarvest = 1000;
-    this.harvestTimeSeconds = (0, _init.getConfigurationValue)(this.agentIdentifier, 'generic_events.harvestTimeSeconds');
+    this.harvestTimeSeconds = agentInit.generic_events.harvestTimeSeconds;
     this.referrerUrl = _runtime2.isBrowserScope && document.referrer ? (0, _cleanUrl.cleanURL)(document.referrer) : undefined;
     this.events = new _eventBuffer.EventBuffer();
     this.#agentRuntime = (0, _runtime.getRuntime)(this.agentIdentifier);
@@ -42,16 +45,16 @@ class Aggregate extends _aggregateBase.AggregateBase {
         (0, _drain.deregisterDrain)(this.agentIdentifier, this.featureName);
         return;
       }
-      if ((0, _init.getConfigurationValue)(this.agentIdentifier, 'page_action.enabled')) {
+      const preHarvestMethods = [];
+      if (agentInit.page_action.enabled) {
         (0, _registerHandler.registerHandler)('api-addPageAction', (timestamp, name, attributes) => {
           this.addEvent({
             ...attributes,
             eventType: 'PageAction',
-            timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(this.#agentRuntime.timeKeeper.convertRelativeTimestamp(timestamp))),
+            timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctRelativeTimestamp(timestamp)),
             timeSinceLoad: timestamp / 1000,
             actionName: name,
             referrerUrl: this.referrerUrl,
-            currentUrl: (0, _cleanUrl.cleanURL)('' + location),
             ...(_runtime2.isBrowserScope && {
               browserWidth: window.document.documentElement?.clientWidth,
               browserHeight: window.document.documentElement?.clientHeight
@@ -59,16 +62,83 @@ class Aggregate extends _aggregateBase.AggregateBase {
           });
         }, this.featureName, this.ee);
       }
+      if (_runtime2.isBrowserScope && agentInit.user_actions.enabled) {
+        this.userActionAggregator = new _userActionsAggregator.UserActionsAggregator();
+        this.addUserAction = aggregatedUserAction => {
+          try {
+            /** The aggregator process only returns an event when it is "done" aggregating -
+             * 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({
+                eventType: 'UserAction',
+                timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctRelativeTimestamp(timeStamp)),
+                action: type,
+                actionCount: aggregatedUserAction.count,
+                actionDuration: aggregatedUserAction.relativeMs[aggregatedUserAction.relativeMs.length - 1],
+                actionMs: aggregatedUserAction.relativeMs,
+                rageClick: aggregatedUserAction.rageClick,
+                target: aggregatedUserAction.selectorPath,
+                ...((0, _iframe.isIFrameWindow)(window) && {
+                  iframe: true
+                }),
+                ...(target?.id && {
+                  targetId: target.id
+                }),
+                ...(target?.tagName && {
+                  targetTag: target.tagName
+                }),
+                ...(target?.type && {
+                  targetType: target.type
+                }),
+                ...(target?.className && {
+                  targetClass: target.className
+                })
+              });
+            }
+          } catch (e) {
+            // do nothing for now
+          }
+        };
+        (0, _registerHandler.registerHandler)('ua', evt => {
+          /** the processor will return the previously aggregated event if it has been completed by processing the current event */
+          this.addUserAction(this.userActionAggregator.process(evt));
+        }, this.featureName, this.ee);
+        preHarvestMethods.push((options = {}) => {
+          /** send whatever UserActions have been aggregated up to this point
+           * if we are in a final harvest. By accessing the aggregationEvent, the aggregation is then force-cleared */
+          if (options.isFinalHarvest) this.addUserAction(this.userActionAggregator.aggregationEvent);
+        });
+      }
       this.harvestScheduler = new _harvestScheduler.HarvestScheduler('ins', {
         onFinished: (...args) => this.onHarvestFinished(...args)
       }, this);
-      this.harvestScheduler.harvest.on('ins', (...args) => this.onHarvestStarted(...args));
+      this.harvestScheduler.harvest.on('ins', (...args) => {
+        preHarvestMethods.forEach(fn => fn(...args));
+        return this.onHarvestStarted(...args);
+      });
       this.harvestScheduler.startTimer(this.harvestTimeSeconds, 0);
       this.drain();
     });
   }
 
   // WARNING: Insights times are in seconds. EXCEPT timestamp, which is in ms.
+  /** Some keys are set by the query params or request headers sent with the harvest and override the body values, so check those before adding new standard body values...
+   * see harvest.js#baseQueryString for more info on the query params
+   * Notably:
+   * * name: set by the `t=` query param
+   * * appId: set by the `a=` query param
+   * * standalone: set by the `sa=` query param
+   * * session: set by the `s=` query param
+   * * sessionTraceId: set by the `ptid=` query param
+   * * userAgent*: set by the userAgent header
+   * @param {object=} obj the event object for storing in the event buffer
+   * @returns void
+   */
   addEvent(obj = {}) {
     if (!obj || !Object.keys(obj).length) return;
     if (!obj.eventType) {
@@ -81,9 +151,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     const defaultEventAttributes = {
       /** should be overridden by the event-specific attributes, but just in case -- set it to now() */
-      timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(this.#agentRuntime.timeKeeper.convertRelativeTimestamp((0, _now.now)()))),
-      /** all generic events require a pageUrl */
-      pageUrl: (0, _cleanUrl.cleanURL)((0, _runtime.getRuntime)(this.agentIdentifier).origin)
+      timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctRelativeTimestamp((0, _now.now)())),
+      /** all generic events require pageUrl(s) */
+      pageUrl: (0, _cleanUrl.cleanURL)('' + _runtime2.initialLocation),
+      currentUrl: (0, _cleanUrl.cleanURL)('' + location)
     };
     const eventAttributes = {
       /** Agent-level custom attributes */
@@ -111,7 +182,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         ins: this.events.buffer
       }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
     };
-    if (options.retry) this.events.hold();
+    if (options.retry) this.events.hold();else this.events.clear();
     return payload;
   }
   onHarvestFinished(result) {

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AggregatedUserAction = void 0;
+var _constants = require("../../constants");
+class AggregatedUserAction {
+  constructor(evt, selectorPath) {
+    this.event = evt;
+    this.count = 1;
+    this.originMs = Math.floor(evt.timeStamp);
+    this.relativeMs = [0];
+    this.selectorPath = selectorPath;
+    this.rageClick = undefined;
+  }
+
+  /**
+   * 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
+   * @param {Event} evt
+   * @returns {void}
+   */
+  aggregate(evt) {
+    this.count++;
+    this.relativeMs.push(Math.floor(evt.timeStamp - this.originMs));
+    if (this.isRageClick()) this.rageClick = true;
+  }
+
+  /**
+   * Determines if the current set of relative ms values constitutes a rage click
+   * @returns {boolean}
+   */
+  isRageClick() {
+    const len = this.relativeMs.length;
+    return this.event.type === 'click' && len >= _constants.RAGE_CLICK_THRESHOLD_EVENTS && this.relativeMs[len - 1] - this.relativeMs[len - _constants.RAGE_CLICK_THRESHOLD_EVENTS] < _constants.RAGE_CLICK_THRESHOLD_MS;
+  }
+}
+exports.AggregatedUserAction = AggregatedUserAction;

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

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UserActionsAggregator = void 0;
+var _selectorPath = require("../../../../common/dom/selector-path");
+var _constants = require("../../constants");
+var _aggregatedUserAction = require("./aggregated-user-action");
+class UserActionsAggregator {
+  /** @type {AggregatedUserAction=} */
+  #aggregationEvent = undefined;
+  #aggregationKey = '';
+  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.
+    // This value may need to be accessed during an unload harvest.
+    const finishedEvent = this.#aggregationEvent;
+    this.#aggregationKey = '';
+    this.#aggregationEvent = undefined;
+    return finishedEvent;
+  }
+
+  /**
+   * Process the event and determine if a new aggregation set should be made or if it should increment the current aggregation
+   * @param {Event} evt The event supplied by the addEventListener callback
+   * @returns {AggregatedUserAction|undefined} The previous aggregation set if it has been completed by processing the current event
+   */
+  process(evt) {
+    if (!evt) return;
+    const selectorPath = getSelectorPath(evt);
+    const aggregationKey = getAggregationKey(evt, selectorPath);
+    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
+      this.#aggregationKey = aggregationKey;
+      this.#aggregationEvent = new _aggregatedUserAction.AggregatedUserAction(evt, selectorPath);
+      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) {
+  let selectorPath;
+  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 selectorPath = (0, _selectorPath.generateSelectorPath)(evt.target);
+  // if STILL no selectorPath, it will return undefined which will skip aggregation for this event
+  return selectorPath;
+}
+
+/**
+ * Returns an aggregation key based on the event type and the selector path of the event's target.
+ * Scrollend events are aggregated into one set, no matter what.
+ * @param {Event} evt
+ * @param {string} selectorPath
+ * @returns {string}
+ */
+function getAggregationKey(evt, selectorPath) {
+  let aggregationKey = evt.type;
+  /** aggregate all scrollends into one set (if sequential), no matter what their target is
+   * the aggregation group's selector path with be reflected as the first one observed
+   * due to the way the aggregation logic works (by storing the initial value and aggregating it) */
+  if (evt.type !== 'scrollend') aggregationKey += '-' + selectorPath;
+  return aggregationKey;
+}

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

@@ -3,8 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.MAX_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = exports.FEATURE_NAME = void 0;
+exports.RAGE_CLICK_THRESHOLD_MS = exports.RAGE_CLICK_THRESHOLD_EVENTS = exports.OBSERVED_WINDOW_EVENTS = exports.OBSERVED_EVENTS = exports.MAX_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = exports.FEATURE_NAME = void 0;
 var _features = require("../../loaders/features/features");
 const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.genericEvents;
 const IDEAL_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = 64000;
-const MAX_PAYLOAD_SIZE = exports.MAX_PAYLOAD_SIZE = 1000000;
+const MAX_PAYLOAD_SIZE = exports.MAX_PAYLOAD_SIZE = 1000000;
+const OBSERVED_EVENTS = exports.OBSERVED_EVENTS = ['auxclick', 'click', 'copy', 'keydown', 'paste', 'scrollend'];
+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;

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

@@ -5,7 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Instrument = exports.GenericEvents = void 0;
 var _init = require("../../../common/config/init");
+var _runtime = require("../../../common/constants/runtime");
 var _drain = require("../../../common/drain/drain");
+var _handle = require("../../../common/event-emitter/handle");
+var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
 var _instrumentBase = require("../../utils/instrument-base");
 var _constants = require("../constants");
 /* Copyright 2020 New Relic Corporation. All rights reserved.
@@ -16,9 +19,17 @@ class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME, auto);
-    const genericEventSourceConfigs = [(0, _init.getConfigurationValue)(this.agentIdentifier, 'page_action.enabled')
+    const agentInit = (0, _init.getConfiguration)(this.agentIdentifier);
+    const genericEventSourceConfigs = [agentInit.page_action.enabled, agentInit.user_actions.enabled
     // other future generic event source configs to go here, like M&Ms, PageResouce, etc.
     ];
+    if (_runtime.isBrowserScope && agentInit.user_actions.enabled) {
+      _constants.OBSERVED_EVENTS.forEach(eventType => (0, _eventListenerOpts.windowAddEventListener)(eventType, evt => (0, _handle.handle)('ua', [evt], undefined, this.featureName, this.ee), true));
+      _constants.OBSERVED_WINDOW_EVENTS.forEach(eventType => (0, _eventListenerOpts.windowAddEventListener)(eventType, evt => (0, _handle.handle)('ua', [evt], undefined, this.featureName, this.ee))
+      // Capture is not used here so that we don't get element focus/blur events, only the window's as they do not bubble. They are also not cancellable, so no worries about being front of line.
+      );
+    }
+
     /** If any of the sources are active, import the aggregator. otherwise deregister */
     if (genericEventSourceConfigs.some(x => x)) this.importAggregator();else (0, _drain.deregisterDrain)(this.agentIdentifier, this.featureName);
   }

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

@@ -167,7 +167,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true;
       params.stack_trace = (0, _formatStackTrace.truncateSize)(stackInfo.stackString);
-      this.observedAt[bucketHash] = Math.floor(agentRuntime.timeKeeper.correctAbsoluteTimestamp(agentRuntime.timeKeeper.convertRelativeTimestamp(time)));
+      this.observedAt[bucketHash] = Math.floor(agentRuntime.timeKeeper.correctRelativeTimestamp(time));
     } else {
       params.browser_stack_hash = (0, _stringHashCode.stringHashCode)(stackInfo.stackString);
     }
@@ -183,7 +183,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       this.pageviewReported[bucketHash] = true;
     }
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash];
-    params.timestamp = Math.floor(agentRuntime.timeKeeper.correctAbsoluteTimestamp(agentRuntime.timeKeeper.convertRelativeTimestamp(time)));
+    params.timestamp = Math.floor(agentRuntime.timeKeeper.correctRelativeTimestamp(time));
     var type = internal ? 'ierr' : 'err';
     var newMetrics = {
       time

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

@@ -66,7 +66,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       return;
     }
     if (typeof message !== 'string' || !message) return (0, _console.warn)(32);
-    const log = new _log.Log(Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(this.#agentRuntime.timeKeeper.convertRelativeTimestamp(timestamp))), message, attributes, level);
+    const log = new _log.Log(Math.floor(this.#agentRuntime.timeKeeper.correctRelativeTimestamp(timestamp)), message, attributes, level);
     const logBytes = log.message.length + (0, _stringify.stringify)(log.attributes).length + log.level.length + 10; // timestamp == 10 chars
 
     if (!this.bufferedLogs.canMerge(logBytes)) {

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

@@ -16,6 +16,7 @@ var _eventListenerOpts = require("../../../common/event-listener/event-listener-
 var _runtime2 = require("../../../common/constants/runtime");
 var _aggregateBase = require("../../utils/aggregate-base");
 var _drain = require("../../../common/drain/drain");
+var _iframe = require("../../../common/dom/iframe");
 // import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
 // import { handleWebsocketEvents } from './websocket-detection'
 
@@ -111,7 +112,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (proxy.assets) this.storeSupportabilityMetrics('Config/AssetsUrl/Changed');
     if (proxy.beacon) this.storeSupportabilityMetrics('Config/BeaconUrl/Changed');
     if (_runtime2.isBrowserScope && window.MutationObserver) {
-      if (window.self !== window.top) {
+      if ((0, _iframe.isIFrameWindow)(window)) {
         this.storeSupportabilityMetrics('Generic/Runtime/IFrame/Detected');
       }
       const preExistingVideos = window.document.querySelectorAll('video').length;