@newrelic/browser-agent 1.267.0 → 1.269.0

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;

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

@@ -118,7 +118,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     queryParameters.fp = _firstPaint.firstPaint.current.value;
     queryParameters.fcp = _firstContentfulPaint.firstContentfulPaint.current.value;
     if (this.timeKeeper?.ready) {
-      queryParameters.timestamp = Math.floor(this.timeKeeper.correctAbsoluteTimestamp(this.timeKeeper.convertRelativeTimestamp((0, _now.now)())));
+      queryParameters.timestamp = Math.floor(this.timeKeeper.correctRelativeTimestamp((0, _now.now)()));
     }
     const rumStartTime = (0, _now.now)();
     harvester.send({

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

@@ -26,6 +26,7 @@ var _drain = require("../../../common/drain/drain");
 var _now = require("../../../common/timing/now");
 var _utils = require("../shared/utils");
 var _agentConstants = require("../../../common/constants/agent-constants");
+var _cleanUrl = require("../../../common/url/clean-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 2023 New Relic Corporation. All rights reserved.
@@ -343,8 +344,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
     const firstEventTimestamp = this.getCorrectedTimestamp(events[0]); // from rrweb node
     const lastEventTimestamp = this.getCorrectedTimestamp(events[events.length - 1]); // from rrweb node
     // from rrweb node || from when the harvest cycle started
-    const firstTimestamp = firstEventTimestamp || Math.floor(this.timeKeeper.correctAbsoluteTimestamp(this.timeKeeper.correctAbsoluteTimestamp(recorderEvents.cycleTimestamp)));
-    const lastTimestamp = lastEventTimestamp || Math.floor(this.timeKeeper.correctAbsoluteTimestamp(this.timeKeeper.convertRelativeTimestamp(relativeNow)));
+    const firstTimestamp = firstEventTimestamp || Math.floor(this.timeKeeper.correctAbsoluteTimestamp(recorderEvents.cycleTimestamp));
+    const lastTimestamp = lastEventTimestamp || Math.floor(this.timeKeeper.correctRelativeTimestamp(relativeNow));
     const agentMetadata = agentRuntime.appMetadata?.agents?.[0] || {};
     return {
       qs: {
@@ -382,7 +383,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
           // customer-defined data should go last so that if it exceeds the query param padding limit it will be truncated instead of important attrs
           ...(endUserId && {
             'enduser.id': this.obfuscator.obfuscateString(endUserId)
-          })
+          }),
+          currentUrl: this.obfuscator.obfuscateString((0, _cleanUrl.cleanURL)('' + location))
           // The Query Param is being arbitrarily limited in length here.  It is also applied when estimating the size of the payload in getPayloadSize()
         }, _constants.QUERY_PARAM_PADDING).substring(1) // remove the leading '&'
       },

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

@@ -17,6 +17,7 @@ var _drain = require("../../../common/drain/drain");
 var _runtime2 = require("../../../common/constants/runtime");
 var _constants2 = require("../../../common/session/constants");
 var _traverse = require("../../../common/util/traverse");
+var _cleanUrl = require("../../../common/url/clean-url");
 const ERROR_MODE_SECONDS_WINDOW = 30 * 1000; // sliding window of nodes to track when simply monitoring (but not harvesting) in error mode
 /** Reserved room for query param attrs */
 const QUERY_PARAM_PADDING = 5000;
@@ -65,6 +66,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
         // if another page's session entity has expired, or another page has transitioned to off and this one hasn't... we can just abort straight away here
         if (this.sessionId !== sessionState.value || eventType === 'cross-tab' && this.scheduler?.started && sessionState.sessionTraceMode === _constants2.MODE.OFF) this.abort(2);
       });
+      if (typeof PerformanceNavigationTiming !== 'undefined') {
+        this.traceStorage.storeTiming(_runtime2.globalScope.performance?.getEntriesByType?.('navigation')[0]);
+      } else {
+        this.traceStorage.storeTiming(_runtime2.globalScope.performance?.timing, true);
+      }
     }
 
     /** ST/SR sampling flow in BCS - https://drive.google.com/file/d/19hwt2oft-8Hh4RrjpLqEXfpP_9wYBLcq/view?usp=sharing */
@@ -90,11 +96,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _registerHandler.registerHandler)('bstApi', (...args) => this.traceStorage.storeSTN(...args), this.featureName, this.ee);
     (0, _registerHandler.registerHandler)('trace-jserror', (...args) => this.traceStorage.storeErrorAgg(...args), this.featureName, this.ee);
     (0, _registerHandler.registerHandler)('pvtAdded', (...args) => this.traceStorage.processPVT(...args), this.featureName, this.ee);
-    if (typeof PerformanceNavigationTiming !== 'undefined') {
-      this.traceStorage.storeTiming(_runtime2.globalScope.performance?.getEntriesByType?.('navigation')[0]);
-    } else {
-      this.traceStorage.storeTiming(_runtime2.globalScope.performance?.timing, true);
-    }
 
     /** Only start actually harvesting if running in full mode at init time */
     if (this.mode === _constants2.MODE.FULL) this.startHarvesting();else {
@@ -156,7 +157,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         type: 'BrowserSessionChunk',
         app_id: this.agentInfo.applicationID,
         protocol_version: '0',
-        timestamp: Math.floor(this.timeKeeper.correctAbsoluteTimestamp(this.timeKeeper.convertRelativeTimestamp(earliestTimeStamp))),
+        timestamp: Math.floor(this.timeKeeper.correctRelativeTimestamp(earliestTimeStamp)),
         attributes: (0, _encode.obj)({
           ...(agentMetadata.entityGuid && {
             entityGuid: agentMetadata.entityGuid
@@ -165,8 +166,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
           // this section of attributes must be controllable and stay below the query param padding limit -- see QUERY_PARAM_PADDING
           // if not, data could be lost to truncation at time of sending, potentially breaking parsing / API behavior in NR1
           // trace payload metadata
-          'trace.firstTimestamp': Math.floor(this.timeKeeper.correctAbsoluteTimestamp(this.timeKeeper.convertRelativeTimestamp(earliestTimeStamp))),
-          'trace.lastTimestamp': Math.floor(this.timeKeeper.correctAbsoluteTimestamp(this.timeKeeper.convertRelativeTimestamp(latestTimeStamp))),
+          'trace.firstTimestamp': Math.floor(this.timeKeeper.correctRelativeTimestamp(earliestTimeStamp)),
+          'trace.lastTimestamp': Math.floor(this.timeKeeper.correctRelativeTimestamp(latestTimeStamp)),
           'trace.nodes': stns.length,
           'trace.originTimestamp': this.timeKeeper.correctedOriginTime,
           // other payload metadata
@@ -182,7 +183,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
           // customer-defined data should go last so that if it exceeds the query param padding limit it will be truncated instead of important attrs
           ...(endUserId && {
             'enduser.id': this.obfuscator.obfuscateString(endUserId)
-          })
+          }),
+          currentUrl: this.obfuscator.obfuscateString((0, _cleanUrl.cleanURL)('' + location))
           // The Query Param is being arbitrarily limited in length here.  It is also applied when estimating the size of the payload in getPayloadSize()
         }, QUERY_PARAM_PADDING).substring(1) // remove the leading '&'
       },

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

@@ -36,6 +36,10 @@ const {
   CB_START,
   FN_END
 } = CONSTANTS;
+
+/**
+ * @deprecated This feature has been deprecated, in favor of `soft_navigations`, which is in limited preview. Consider using/importing `SoftNavigations` instead. To gain access to the limited preview, please see https://docs.newrelic.com/docs/browser/single-page-app-monitoring/get-started/browser-spa-v2/ for more information. This feature will be removed in a future release.
+ */
 class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator, auto = true) {

package/dist/cjs/loaders/agent-base.js

@@ -176,6 +176,7 @@ class AgentBase {
    * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/interaction/}
    * @returns {InteractionInstance} An API object that is bound to a specific BrowserInteraction event. Each time this method is called for the same BrowserInteraction, a new object is created, but it still references the same interaction.
    *  - Note: Does not apply to MicroAgent
+   *  - Deprecation Notice: interaction.createTracer is deprecated.  See https://docs.newrelic.com/eol/2024/04/eol-04-24-24-createtracer/ for more information.
   */
   interaction() {
     return this.#callMethod('interaction');

package/dist/cjs/loaders/micro-agent.js

@@ -20,7 +20,7 @@ var _agentBase = require("./agent-base");
 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; } // loader files
 // core files
-const nonAutoFeatures = [_features.FEATURE_NAMES.jserrors, _features.FEATURE_NAMES.genericEvents, _features.FEATURE_NAMES.metrics];
+const nonAutoFeatures = [_features.FEATURE_NAMES.jserrors, _features.FEATURE_NAMES.genericEvents, _features.FEATURE_NAMES.metrics, _features.FEATURE_NAMES.logging];
 
 /**
  * A minimal agent class designed to only respond to manual user input. As such, this class does not

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

@@ -72,6 +72,9 @@ const model = () => {
     page_action: {
       enabled: true
     },
+    user_actions: {
+      enabled: true
+    },
     page_view_event: {
       enabled: true,
       autoStart: true

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.267.0";
+export const VERSION = "1.269.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.267.0";
+export const VERSION = "1.269.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -0,0 +1,4 @@
+export function isIFrameWindow(windowObject) {
+  if (!windowObject) return false;
+  return windowObject.self !== windowObject.top;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Generates a CSS selector path for the given element, if possible
+ * @param {HTMLElement} elem
+ * @param {boolean} includeId
+ * @param {boolean} includeClass
+ * @returns {string|undefined}
+ */
+export 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;
+};

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

@@ -1,32 +1,9 @@
-import { globalScope } from '../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;
-    }
-  };
-  globalScope.addEventListener('test', null, options);
-  globalScope.removeEventListener('test', null, options);
-} catch (err) {}
 export 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/esm/common/timing/time-keeper.js

@@ -102,6 +102,15 @@ export 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/esm/common/util/stringify.js

@@ -31,7 +31,7 @@ const getCircularReplacer = () => {
  */
 export function stringify(val) {
   try {
-    return JSON.stringify(val, getCircularReplacer());
+    return JSON.stringify(val, getCircularReplacer()) ?? '';
   } catch (e) {
     try {
       ee.emit('internal-error', [e]);

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

@@ -6,10 +6,10 @@ import { stringify } from '../../../common/util/stringify';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { cleanURL } from '../../../common/url/clean-url';
 import { getInfo } from '../../../common/config/info';
-import { getConfigurationValue } from '../../../common/config/init';
+import { getConfiguration } from '../../../common/config/init';
 import { getRuntime } from '../../../common/config/runtime';
 import { FEATURE_NAME } from '../constants';
-import { isBrowserScope } from '../../../common/constants/runtime';
+import { initialLocation, isBrowserScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { warn } from '../../../common/util/console';
 import { now } from '../../../common/timing/now';
@@ -19,13 +19,16 @@ import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { EventBuffer } from '../../utils/event-buffer';
 import { applyFnToProps } from '../../../common/util/traverse';
 import { IDEAL_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
+import { UserActionsAggregator } from './user-actions/user-actions-aggregator';
+import { isIFrameWindow } from '../../../common/dom/iframe';
 export class Aggregate extends AggregateBase {
   #agentRuntime;
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
+    const agentInit = getConfiguration(this.agentIdentifier);
     this.eventsPerHarvest = 1000;
-    this.harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'generic_events.harvestTimeSeconds');
+    this.harvestTimeSeconds = agentInit.generic_events.harvestTimeSeconds;
     this.referrerUrl = isBrowserScope && document.referrer ? cleanURL(document.referrer) : undefined;
     this.events = new EventBuffer();
     this.#agentRuntime = getRuntime(this.agentIdentifier);
@@ -35,16 +38,16 @@ export class Aggregate extends AggregateBase {
         deregisterDrain(this.agentIdentifier, this.featureName);
         return;
       }
-      if (getConfigurationValue(this.agentIdentifier, 'page_action.enabled')) {
+      const preHarvestMethods = [];
+      if (agentInit.page_action.enabled) {
         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: cleanURL('' + location),
             ...(isBrowserScope && {
               browserWidth: window.document.documentElement?.clientWidth,
               browserHeight: window.document.documentElement?.clientHeight
@@ -52,16 +55,83 @@ export class Aggregate extends AggregateBase {
           });
         }, this.featureName, this.ee);
       }
+      if (isBrowserScope && agentInit.user_actions.enabled) {
+        this.userActionAggregator = new 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,
+                ...(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
+          }
+        };
+        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('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) {
@@ -74,9 +144,10 @@ export class Aggregate extends 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(now()))),
-      /** all generic events require a pageUrl */
-      pageUrl: cleanURL(getRuntime(this.agentIdentifier).origin)
+      timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctRelativeTimestamp(now())),
+      /** all generic events require pageUrl(s) */
+      pageUrl: cleanURL('' + initialLocation),
+      currentUrl: cleanURL('' + location)
     };
     const eventAttributes = {
       /** Agent-level custom attributes */
@@ -104,7 +175,7 @@ export class Aggregate extends 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/esm/features/generic_events/aggregate/user-actions/aggregated-user-action.js

@@ -0,0 +1,32 @@
+import { RAGE_CLICK_THRESHOLD_EVENTS, RAGE_CLICK_THRESHOLD_MS } from '../../constants';
+export 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 >= RAGE_CLICK_THRESHOLD_EVENTS && this.relativeMs[len - 1] - this.relativeMs[len - RAGE_CLICK_THRESHOLD_EVENTS] < RAGE_CLICK_THRESHOLD_MS;
+  }
+}

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

@@ -0,0 +1,70 @@
+import { generateSelectorPath } from '../../../../common/dom/selector-path';
+import { OBSERVED_WINDOW_EVENTS } from '../../constants';
+import { AggregatedUserAction } from './aggregated-user-action';
+export 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(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}
+ */
+function getSelectorPath(evt) {
+  let selectorPath;
+  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 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/esm/features/generic_events/constants.js

@@ -1,4 +1,8 @@
 import { FEATURE_NAMES } from '../../loaders/features/features';
 export const FEATURE_NAME = FEATURE_NAMES.genericEvents;
 export const IDEAL_PAYLOAD_SIZE = 64000;
-export const MAX_PAYLOAD_SIZE = 1000000;
+export const MAX_PAYLOAD_SIZE = 1000000;
+export const OBSERVED_EVENTS = ['auxclick', 'click', 'copy', 'keydown', 'paste', 'scrollend'];
+export const OBSERVED_WINDOW_EVENTS = ['focus', 'blur'];
+export const RAGE_CLICK_THRESHOLD_EVENTS = 4;
+export const RAGE_CLICK_THRESHOLD_MS = 1000;

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

@@ -2,17 +2,28 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { getConfigurationValue } from '../../../common/config/init';
+import { getConfiguration } from '../../../common/config/init';
+import { isBrowserScope } from '../../../common/constants/runtime';
 import { deregisterDrain } from '../../../common/drain/drain';
+import { handle } from '../../../common/event-emitter/handle';
+import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
 import { InstrumentBase } from '../../utils/instrument-base';
-import { FEATURE_NAME } from '../constants';
+import { FEATURE_NAME, OBSERVED_EVENTS, OBSERVED_WINDOW_EVENTS } from '../constants';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
-    const genericEventSourceConfigs = [getConfigurationValue(this.agentIdentifier, 'page_action.enabled')
+    const agentInit = 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 (isBrowserScope && agentInit.user_actions.enabled) {
+      OBSERVED_EVENTS.forEach(eventType => windowAddEventListener(eventType, evt => handle('ua', [evt], undefined, this.featureName, this.ee), true));
+      OBSERVED_WINDOW_EVENTS.forEach(eventType => windowAddEventListener(eventType, evt => 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 deregisterDrain(this.agentIdentifier, this.featureName);
   }