@newrelic/browser-agent 1.267.0 → 1.268.0

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

@@ -0,0 +1,22 @@
+export class AggregatedUserAction {
+    constructor(evt: any, selectorPath: any);
+    event: any;
+    count: number;
+    originMs: number;
+    relativeMs: number[];
+    selectorPath: any;
+    rageClick: boolean | 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: Event): void;
+    /**
+     * Determines if the current set of relative ms values constitutes a rage click
+     * @returns {boolean}
+     */
+    isRageClick(): boolean;
+}
+//# sourceMappingURL=aggregated-user-action.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregated-user-action.d.ts","sourceRoot":"","sources":["../../../../../../src/features/generic_events/aggregate/user-actions/aggregated-user-action.js"],"names":[],"mappings":"AAEA;IACE,yCAOC;IANC,WAAgB;IAChB,cAAc;IACd,iBAAyC;IACzC,qBAAqB;IACrB,kBAAgC;IAChC,+BAA0B;IAG5B;;;;;OAKG;IACH,eAHW,KAAK,GACH,IAAI,CAMhB;IAED;;;OAGG;IACH,eAFa,OAAO,CAKnB;CACF"}

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

@@ -0,0 +1,12 @@
+export class UserActionsAggregator {
+    get aggregationEvent(): AggregatedUserAction | undefined;
+    /**
+     * Process the event and determine if a new aggregation set should be made or if it should increment the current aggregation
+     * @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: Event): AggregatedUserAction | undefined;
+    #private;
+}
+import { AggregatedUserAction } from './aggregated-user-action';
+//# sourceMappingURL=user-actions-aggregator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user-actions-aggregator.d.ts","sourceRoot":"","sources":["../../../../../../src/features/generic_events/aggregate/user-actions/user-actions-aggregator.js"],"names":[],"mappings":"AAIA;IAKE,yDAQC;IAED;;;;OAIG;IACH,aAHW,KAAK,GACH,oBAAoB,GAAC,SAAS,CAiB1C;;CACF;qCAtCoC,0BAA0B"}

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

@@ -1,4 +1,8 @@
 export const FEATURE_NAME: string;
 export const IDEAL_PAYLOAD_SIZE: 64000;
 export const MAX_PAYLOAD_SIZE: 1000000;
+export const OBSERVED_EVENTS: string[];
+export const OBSERVED_WINDOW_EVENTS: string[];
+export const RAGE_CLICK_THRESHOLD_EVENTS: 4;
+export const RAGE_CLICK_THRESHOLD_MS: 1000;
 //# sourceMappingURL=constants.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/generic_events/constants.js"],"names":[],"mappings":"AAEA,kCAAuD;AACvD,uCAAuC;AACvC,uCAAuC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/generic_events/constants.js"],"names":[],"mappings":"AAEA,kCAAuD;AACvD,uCAAuC;AACvC,uCAAuC;AAEvC,uCAA6F;AAC7F,8CAAuD;AAEvD,4CAA4C;AAC5C,2CAA2C"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/instrument/index.js"],"names":[],"mappings":"AASA;IACE,2BAAiC;IACjC,mEASC;CACF;AAED,8CAAuC;+BAjBR,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/instrument/index.js"],"names":[],"mappings":"AAYA;IACE,2BAAiC;IACjC,mEAsBC;CACF;AAED,8CAAuC;+BA9BR,6BAA6B"}

package/dist/types/features/jserrors/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AA2BA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAgCC;IA7BC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,uCAA4B;IAC5B,qBAAwB;IA0B1B;;;MA2BC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4FAgGC;IA4BD,yDA6BC;IAED,qFAOC;;CAwBF;wBA9SY,OAAO,0BAA0B,EAAE,SAAS;8BAP3B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AA2BA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAgCC;IA7BC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,uCAA4B;IAC5B,qBAAwB;IA0B1B;;;MA2BC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4FA4FC;IA4BD,yDA6BC;IAED,qFAOC;;CAwBF;wBA1SY,OAAO,0BAA0B,EAAE,SAAS;8BAP3B,4BAA4B"}

package/dist/types/features/logging/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/logging/aggregate/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IAGjC,mDAwBC;IArBC,+BAA+B;IAC/B,0BAAqC;IAKrC,wBAAmG;IAGjG,4BAKQ;IASZ,+EA+CC;IAED;;;;;;gBASQ,0FAA0F;;;;;;;;;;;;YAY5F,0DAA0D;;;kBAY/D;IAED,qCAGC;;CACF;8BA9H6B,4BAA4B;4BAM9B,0BAA0B;iCAVrB,2CAA2C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/logging/aggregate/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IAGjC,mDAwBC;IArBC,+BAA+B;IAC/B,0BAAqC;IAKrC,wBAAmG;IAGjG,4BAKQ;IASZ,+EA6CC;IAED;;;;;;gBASQ,0FAA0F;;;;;;;;;;;;YAY5F,0DAA0D;;;kBAY/D;IAED,qCAGC;;CACF;8BA5H6B,4BAA4B;4BAM9B,0BAA0B;iCAVrB,2CAA2C"}

package/dist/types/features/metrics/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/metrics/aggregate/index.js"],"names":[],"mappings":"AAeA;IACE,2BAAiC;IACjC,mDAsBC;IAED,wDAKC;IAED,iDAKC;IAED,qBAqEC;IAED,0BAOC;IAED,eAkCC;IA/BG,mCAAyB;CAgC9B;8BAhK6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/metrics/aggregate/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IACjC,mDAsBC;IAED,wDAKC;IAED,iDAKC;IAED,qBAqEC;IAED,0BAOC;IAED,eAkCC;IA/BG,mCAAyB;CAgC9B;8BAjK6B,4BAA4B"}

package/dist/types/features/page_view_event/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAA2C;IAC3C,mDA0BC;IAvBC,wBAAwB;IACxB,8BAA8B;IAC9B,8BAA8B;IAC9B,uBAAsD;IAsBxD,gBAmGC;CACF;8BA1I6B,4BAA4B;2BAK/B,oCAAoC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAA2C;IAC3C,mDA0BC;IAvBC,wBAAwB;IACxB,8BAA8B;IAC9B,8BAA8B;IAC9B,uBAAsD;IAsBxD,gBAiGC;CACF;8BAxI6B,4BAA4B;2BAK/B,oCAAoC"}

package/dist/types/features/session_replay/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AA+BA;IACE,2BAAiC;IAIjC,8DAsGC;IAzGD,aAAe;IAKb,8GAA8G;IAC9G,wBAAgH;IAChH,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAEnB,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IAC9B,kBAA+C;IAoC/C,4BAKQ;IA4CV,0BAMC;IAED,qBAWC;IAED;;;;;;;OAOG;IACH,gDAHW,OAAO,GACL,IAAI,CA8DhB;IAED,2BASC;IAED;;;;;;;;;;;;oBAiDC;IAED,sCAIC;IAED;;;;;;;;;;MA2EC;IAED,qCAOC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,+CAUC;IAED,yCAGC;CACF;8BAhZ6B,4BAA4B;iCALzB,2CAA2C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AAgCA;IACE,2BAAiC;IAIjC,8DAsGC;IAzGD,aAAe;IAKb,8GAA8G;IAC9G,wBAAgH;IAChH,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAEnB,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IAC9B,kBAA+C;IAoC/C,4BAKQ;IA4CV,0BAMC;IAED,qBAWC;IAED;;;;;;;OAOG;IACH,gDAHW,OAAO,GACL,IAAI,CA8DhB;IAED,2BASC;IAED;;;;;;;;;;;;oBAiDC;IAED,sCAIC;IAED;;;;;;;;;;MAwEC;IAED,qCAOC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,+CAUC;IAED,yCAGC;CACF;8BA9Y6B,4BAA4B;iCALzB,2CAA2C"}

package/dist/types/features/session_trace/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IAEjC,mDAmBC;IAjBC,kBAA+C;IAC/C,eAAyC;IAEzC,0FAA0F;IAC1F,wBAAqB;IACrB,wBAA0G;IAC1G,0GAA0G;IAC1G,cAAyB;IACzB,mIAAmI;IACnI,uBAA0B;IAC1B,0CAA0C;IAC1C,oBAAuB;IACvB,wIAAwI;IACxI,2BAA0C;IAM5C,gLAAgL;IAChL,mEAoEC;IA/DG,iCAAuB;IACvB,yJAAyJ;IACzJ,UAAkC;IAClC,eAAuD;IAmBD,UAA4D;IASpH,wCAKQ;IA6BV,kJAAkJ;IAClJ,wBAIC;IAED,iJAAiJ;IACjJ;;;;;;;;;;MAkEC;IAED;;OAEG;IACH,qCAKC;IAED,8DAA8D;IAC9D,qBAUC;IAED,2DAA2D;IAC3D,yBAKC;CACF;8BApN6B,4BAA4B;6BAC7B,iBAAiB;iCANb,2CAA2C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAAiC;IAEjC,mDAmBC;IAjBC,kBAA+C;IAC/C,eAAyC;IAEzC,0FAA0F;IAC1F,wBAAqB;IACrB,wBAA0G;IAC1G,0GAA0G;IAC1G,cAAyB;IACzB,mIAAmI;IACnI,uBAA0B;IAC1B,0CAA0C;IAC1C,oBAAuB;IACvB,wIAAwI;IACxI,2BAA0C;IAM5C,gLAAgL;IAChL,mEAoEC;IA/DG,iCAAuB;IACvB,yJAAyJ;IACzJ,UAAkC;IAClC,eAAuD;IAmBD,UAA4D;IASpH,wCAKQ;IA6BV,kJAAkJ;IAClJ,wBAIC;IAED,iJAAiJ;IACjJ;;;;;;;;;;MA6DC;IAED;;OAEG;IACH,qCAKC;IAED,8DAA8D;IAC9D,qBAUC;IAED,2DAA2D;IAC3D,yBAKC;CACF;8BAhN6B,4BAA4B;6BAC7B,iBAAiB;iCANb,2CAA2C"}

package/package.json

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

package/src/common/config/init.js

@@ -48,6 +48,7 @@ const model = () => {
     metrics: { enabled: true, autoStart: true },
     obfuscate: undefined,
     page_action: { enabled: true },
+    user_actions: { enabled: true },
     page_view_event: { enabled: true, autoStart: true },
     page_view_timing: { enabled: true, harvestTimeSeconds: 30, autoStart: true },
     privacy: { cookies_enabled: true }, // *cli - per discussion, default should be true

package/src/common/dom/iframe.js

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

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

@@ -0,0 +1,45 @@
+/**
+ * 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 ? `#${id}` : '',
+        pathSelector ? `>${pathSelector}` : ''
+      ].join('')
+
+      pathSelector = selector
+      elem = elem.parentNode
+    }
+  } catch (err) {
+  // do nothing for now
+  }
+
+  return pathSelector ? index ? `${pathSelector}:nth-of-type(${index})` : pathSelector : undefined
+}

package/src/common/event-listener/event-listener-opts.js

@@ -1,34 +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
-        signal: abortSignal
-      }
-    : !!useCapture // mainly just IE11 doesn't support third param options under EventTarget API
+  return {
+    capture: useCapture,
+    passive: false,
+    signal: abortSignal
+  }
 }
 
 /** Do not use this within the worker context. */

package/src/common/timing/__mocks__/time-keeper.js

@@ -3,4 +3,5 @@ export const TimeKeeper = jest.fn(function () {
   this.convertRelativeTimestamp = jest.fn()
   this.convertAbsoluteTimestamp = jest.fn()
   this.correctAbsoluteTimestamp = jest.fn()
+  this.correctRelativeTimestamp = jest.fn()
 })

package/src/common/timing/time-keeper.js

@@ -107,6 +107,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/src/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/src/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,15 +19,18 @@ 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
 
@@ -42,18 +45,17 @@ export class Aggregate extends AggregateBase {
         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
@@ -62,8 +64,53 @@ 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()
@@ -71,6 +118,18 @@ export class Aggregate extends AggregateBase {
   }
 
   // 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) {
@@ -85,11 +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 = {
@@ -121,6 +179,8 @@ export class Aggregate extends AggregateBase {
     })
 
     if (options.retry) this.events.hold()
+    else this.events.clear()
+
     return payload
   }
 

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

@@ -0,0 +1,33 @@
+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/src/features/generic_events/aggregate/user-actions/user-actions-aggregator.js

@@ -0,0 +1,73 @@
+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/src/features/generic_events/constants.js

@@ -3,3 +3,9 @@ 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 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/src/features/generic_events/instrument/index.js

@@ -2,19 +2,35 @@
  * 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 agentInit = getConfiguration(this.agentIdentifier)
     const genericEventSourceConfigs = [
-      getConfigurationValue(this.agentIdentifier, 'page_action.enabled')
+      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)

package/src/features/jserrors/aggregate/index.js

@@ -184,9 +184,7 @@ export class Aggregate extends AggregateBase {
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true
       params.stack_trace = 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 = stringHashCode(stackInfo.stackString)
     }
@@ -203,9 +201,7 @@ export class Aggregate extends AggregateBase {
     }
 
     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/src/features/logging/aggregate/index.js

@@ -70,9 +70,7 @@ export class Aggregate extends AggregateBase {
     if (typeof message !== 'string' || !message) return warn(32)
 
     const log = new Log(
-      Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(
-        this.#agentRuntime.timeKeeper.convertRelativeTimestamp(timestamp)
-      )),
+      Math.floor(this.#agentRuntime.timeKeeper.correctRelativeTimestamp(timestamp)),
       message,
       attributes,
       level

package/src/features/metrics/aggregate/index.js

@@ -10,6 +10,7 @@ import { windowAddEventListener } from '../../../common/event-listener/event-lis
 import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { deregisterDrain } from '../../../common/drain/drain'
+import { isIFrameWindow } from '../../../common/dom/iframe'
 // import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
 // import { handleWebsocketEvents } from './websocket-detection'
 
@@ -101,7 +102,7 @@ export class Aggregate extends AggregateBase {
     if (proxy.beacon) this.storeSupportabilityMetrics('Config/BeaconUrl/Changed')
 
     if (isBrowserScope && window.MutationObserver) {
-      if (window.self !== window.top) { this.storeSupportabilityMetrics('Generic/Runtime/IFrame/Detected') }
+      if (isIFrameWindow(window)) { this.storeSupportabilityMetrics('Generic/Runtime/IFrame/Detected') }
       const preExistingVideos = window.document.querySelectorAll('video').length
       if (preExistingVideos) this.storeSupportabilityMetrics('Generic/VideoElement/Added', preExistingVideos)
       const preExistingIframes = window.document.querySelectorAll('iframe').length

package/src/features/page_view_event/aggregate/index.js

@@ -106,9 +106,7 @@ export class Aggregate extends AggregateBase {
     queryParameters.fcp = firstContentfulPaint.current.value
 
     if (this.timeKeeper?.ready) {
-      queryParameters.timestamp = Math.floor(this.timeKeeper.correctAbsoluteTimestamp(
-        this.timeKeeper.convertRelativeTimestamp(now())
-      ))
+      queryParameters.timestamp = Math.floor(this.timeKeeper.correctRelativeTimestamp(now()))
     }
 
     const rumStartTime = now()