@newrelic/browser-agent 1.267.0 → 1.268.0

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);
   }

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

@@ -162,7 +162,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);
     }
@@ -178,7 +178,7 @@ export class Aggregate extends 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/esm/features/logging/aggregate/index.js

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

package/dist/esm/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'
 
@@ -105,7 +106,7 @@ export class Aggregate extends AggregateBase {
     if (proxy.assets) this.storeSupportabilityMetrics('Config/AssetsUrl/Changed');
     if (proxy.beacon) this.storeSupportabilityMetrics('Config/BeaconUrl/Changed');
     if (isBrowserScope && window.MutationObserver) {
-      if (window.self !== window.top) {
+      if (isIFrameWindow(window)) {
         this.storeSupportabilityMetrics('Generic/Runtime/IFrame/Detected');
       }
       const preExistingVideos = window.document.querySelectorAll('video').length;

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

@@ -110,7 +110,7 @@ export class Aggregate extends AggregateBase {
     queryParameters.fp = firstPaint.current.value;
     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();
     harvester.send({

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

@@ -28,6 +28,7 @@ import { deregisterDrain } from '../../../common/drain/drain';
 import { now } from '../../../common/timing/now';
 import { buildNRMetaNode } from '../shared/utils';
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
+import { cleanURL } from '../../../common/url/clean-url';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   mode = MODE.OFF;
@@ -338,8 +339,8 @@ export class Aggregate extends 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: {
@@ -377,7 +378,8 @@ export class Aggregate extends 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(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/esm/features/session_trace/aggregate/index.js

@@ -11,6 +11,7 @@ import { deregisterDrain } from '../../../common/drain/drain';
 import { globalScope } from '../../../common/constants/runtime';
 import { MODE, SESSION_EVENTS } from '../../../common/session/constants';
 import { applyFnToProps } from '../../../common/util/traverse';
+import { cleanURL } from '../../../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;
@@ -150,7 +151,7 @@ export class Aggregate extends 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: encodeObj({
           ...(agentMetadata.entityGuid && {
             entityGuid: agentMetadata.entityGuid
@@ -159,8 +160,8 @@ export class Aggregate extends 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
@@ -176,7 +177,8 @@ export class Aggregate extends 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(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/types/common/config/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../src/common/config/init.js"],"names":[],"mappings":"AAiHA,+CAIC;AAED,0DAKC;AAED,+DAYC"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../src/common/config/init.js"],"names":[],"mappings":"AAkHA,+CAIC;AAED,0DAKC;AAED,+DAYC"}

package/dist/types/common/dom/iframe.d.ts

@@ -0,0 +1,2 @@
+export function isIFrameWindow(windowObject: any): boolean;
+//# sourceMappingURL=iframe.d.ts.map

package/dist/types/common/dom/iframe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iframe.d.ts","sourceRoot":"","sources":["../../../../src/common/dom/iframe.js"],"names":[],"mappings":"AAAA,2DAGC"}

package/dist/types/common/dom/selector-path.d.ts

@@ -0,0 +1,2 @@
+export function generateSelectorPath(elem: HTMLElement): string | undefined;
+//# sourceMappingURL=selector-path.d.ts.map

package/dist/types/common/dom/selector-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selector-path.d.ts","sourceRoot":"","sources":["../../../../src/common/dom/selector-path.js"],"names":[],"mappings":"AAOO,2CALI,WAAW,GAGT,MAAM,GAAC,SAAS,CAuC5B"}

package/dist/types/common/event-listener/event-listener-opts.d.ts

@@ -1,5 +1,5 @@
-export function eventListenerOpts(useCapture: any, abortSignal: any): boolean | {
-    capture: boolean;
+export function eventListenerOpts(useCapture: any, abortSignal: any): {
+    capture: any;
     passive: boolean;
     signal: any;
 };

package/dist/types/common/event-listener/event-listener-opts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-listener-opts.d.ts","sourceRoot":"","sources":["../../../../src/common/event-listener/event-listener-opts.js"],"names":[],"mappings":"AAuBA;;;;EAQC;AAED,iDAAiD;AACjD,wHAEC;AACD,iDAAiD;AACjD,0HAEC"}
+{"version":3,"file":"event-listener-opts.d.ts","sourceRoot":"","sources":["../../../../src/common/event-listener/event-listener-opts.js"],"names":[],"mappings":"AAAA;;;;EAMC;AAED,iDAAiD;AACjD,wHAEC;AACD,iDAAiD;AACjD,0HAEC"}

package/dist/types/common/timing/time-keeper.d.ts

@@ -36,6 +36,12 @@ export class TimeKeeper {
      * @return {number} Corrected unix/epoch timestamp
      */
     correctAbsoluteTimestamp(timestamp: number): number;
+    /**
+     * Corrects relative timestamp to NR server time (epoch).
+     * @param {DOMHighResTimeStamp} relativeTime
+     * @returns {number}
+     */
+    correctRelativeTimestamp(relativeTime: DOMHighResTimeStamp): number;
     /** Process the session entity and use the info to set the main time calculations if present */
     processStoredDiff(): void;
     #private;

package/dist/types/common/timing/time-keeper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-keeper.d.ts","sourceRoot":"","sources":["../../../../src/common/timing/time-keeper.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IA2BE,kCAGC;IAED,qBAEC;IAED,kCAEC;IAED,4BAEC;IAED;;;;;;OAMG;IACH,8BALsB,cAAc,aACf,MAAM,WACR,MAAM,gBACD,MAAM,QAqB7B;IAED;;;;;OAKG;IACH,uCAHwB,MAAM,GACjB,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0CAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAHqB,MAAM,GACf,MAAM,CAIjB;IAED,+FAA+F;IAC/F,0BASC;;CACF"}
+{"version":3,"file":"time-keeper.d.ts","sourceRoot":"","sources":["../../../../src/common/timing/time-keeper.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IA2BE,kCAGC;IAED,qBAEC;IAED,kCAEC;IAED,4BAEC;IAED;;;;;;OAMG;IACH,8BALsB,cAAc,aACf,MAAM,WACR,MAAM,gBACD,MAAM,QAqB7B;IAED;;;;;OAKG;IACH,uCAHwB,MAAM,GACjB,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0CAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,oCAHqB,MAAM,GACf,MAAM,CAIjB;IAED;;;;OAIG;IACH,uCAHW,mBAAmB,GACjB,MAAM,CAIlB;IAED,+FAA+F;IAC/F,0BASC;;CACF"}

package/dist/types/features/generic_events/aggregate/index.d.ts

@@ -5,8 +5,22 @@ export class Aggregate extends AggregateBase {
     harvestTimeSeconds: any;
     referrerUrl: string | undefined;
     events: EventBuffer;
+    userActionAggregator: UserActionsAggregator;
+    addUserAction: (aggregatedUserAction: any) => void;
     harvestScheduler: HarvestScheduler;
-    addEvent(obj?: {}): void;
+    /** 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?: object | undefined): void;
     onHarvestStarted(options: any): {
         qs: {
             ua: any;
@@ -20,5 +34,6 @@ export class Aggregate extends AggregateBase {
 }
 import { AggregateBase } from '../../utils/aggregate-base';
 import { EventBuffer } from '../../utils/event-buffer';
+import { UserActionsAggregator } from './user-actions/user-actions-aggregator';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/aggregate/index.js"],"names":[],"mappings":"AAsBA;IAEE,2BAAiC;IACjC,mDA6CC;IA1CC,yBAA4B;IAC5B,wBAA0G;IAE1G,gCAAkG;IAElG,oBAA+B;IA+B7B,mCAAuH;IAS3H,yBAiCC;IAED;;;;;;kBAgBC;IAED,qCAGC;IAED,yBAMC;;CACF;8BA9H6B,4BAA4B;4BAM9B,0BAA0B;iCAbrB,2CAA2C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/generic_events/aggregate/index.js"],"names":[],"mappings":"AAwBA;IAEE,2BAAiC;IACjC,mDA0FC;IAtFC,yBAA4B;IAC5B,wBAAqE;IAErE,gCAAkG;IAElG,oBAA+B;IA+B3B,4CAAuD;IAEvD,mDAyBC;IAcH,mCAAuH;IAY3H;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,YAAC,QAmCjB;IAED;;;;;;kBAkBC;IAED,qCAGC;IAED,yBAMC;;CACF;8BA1L6B,4BAA4B;4BAM9B,0BAA0B;sCAGhB,wCAAwC;iCAhB7C,2CAA2C"}