@newrelic/browser-agent 1.267.0 → 1.268.0

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.268.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.267.0...v1.268.0) (2024-10-08)
+
+
+### Features
+
+* Add UserAction to GenericEvents ([#1186](https://github.com/newrelic/newrelic-browser-agent/issues/1186)) ([1b0bb1d](https://github.com/newrelic/newrelic-browser-agent/commit/1b0bb1dd992674f77c41a73449b64b022cdfc83c))
+* Aggregate UserActions ([#1195](https://github.com/newrelic/newrelic-browser-agent/issues/1195)) ([b5e4c6d](https://github.com/newrelic/newrelic-browser-agent/commit/b5e4c6dcdcfce3ab88132f2a1d82d4d02ab7640b))
+
+
+### Bug Fixes
+
+* Always return a string for custom stringify method ([#1207](https://github.com/newrelic/newrelic-browser-agent/issues/1207)) ([94a9a0b](https://github.com/newrelic/newrelic-browser-agent/commit/94a9a0b465e9ea34132317236d47ac9f62ee4051))
+* Force generic events feature to clear buffer when unloading ([#1202](https://github.com/newrelic/newrelic-browser-agent/issues/1202)) ([d3fac07](https://github.com/newrelic/newrelic-browser-agent/commit/d3fac07379d18c98e9838152a31a482ff25fe5bf))
+
 ## [1.267.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.266.0...v1.267.0) (2024-09-23)
 
 

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -107,6 +107,15 @@ class TimeKeeper {
     return timestamp - this.#localTimeDiff;
   }
 
+  /**
+   * Corrects relative timestamp to NR server time (epoch).
+   * @param {DOMHighResTimeStamp} relativeTime
+   * @returns {number}
+   */
+  correctRelativeTimestamp(relativeTime) {
+    return this.correctAbsoluteTimestamp(this.convertRelativeTimestamp(relativeTime));
+  }
+
   /** Process the session entity and use the info to set the main time calculations if present */
   processStoredDiff() {
     if (this.#ready) return; // Time diff has already been calculated

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

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

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AggregatedUserAction = void 0;
+var _constants = require("../../constants");
+class AggregatedUserAction {
+  constructor(evt, selectorPath) {
+    this.event = evt;
+    this.count = 1;
+    this.originMs = Math.floor(evt.timeStamp);
+    this.relativeMs = [0];
+    this.selectorPath = selectorPath;
+    this.rageClick = undefined;
+  }
+
+  /**
+   * Aggregates the count and maintains the relative MS array for matching events
+   * Will determine if a rage click was observed as part of the aggregation
+   * @param {Event} evt
+   * @returns {void}
+   */
+  aggregate(evt) {
+    this.count++;
+    this.relativeMs.push(Math.floor(evt.timeStamp - this.originMs));
+    if (this.isRageClick()) this.rageClick = true;
+  }
+
+  /**
+   * Determines if the current set of relative ms values constitutes a rage click
+   * @returns {boolean}
+   */
+  isRageClick() {
+    const len = this.relativeMs.length;
+    return this.event.type === 'click' && len >= _constants.RAGE_CLICK_THRESHOLD_EVENTS && this.relativeMs[len - 1] - this.relativeMs[len - _constants.RAGE_CLICK_THRESHOLD_EVENTS] < _constants.RAGE_CLICK_THRESHOLD_MS;
+  }
+}
+exports.AggregatedUserAction = AggregatedUserAction;

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

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UserActionsAggregator = void 0;
+var _selectorPath = require("../../../../common/dom/selector-path");
+var _constants = require("../../constants");
+var _aggregatedUserAction = require("./aggregated-user-action");
+class UserActionsAggregator {
+  /** @type {AggregatedUserAction=} */
+  #aggregationEvent = undefined;
+  #aggregationKey = '';
+  get aggregationEvent() {
+    // if this is accessed externally, we need to be done aggregating on it
+    // to prevent potential mutability and duplication issues, so the state is cleared upon returning.
+    // This value may need to be accessed during an unload harvest.
+    const finishedEvent = this.#aggregationEvent;
+    this.#aggregationKey = '';
+    this.#aggregationEvent = undefined;
+    return finishedEvent;
+  }
+
+  /**
+   * Process the event and determine if a new aggregation set should be made or if it should increment the current aggregation
+   * @param {Event} evt The event supplied by the addEventListener callback
+   * @returns {AggregatedUserAction|undefined} The previous aggregation set if it has been completed by processing the current event
+   */
+  process(evt) {
+    if (!evt) return;
+    const selectorPath = getSelectorPath(evt);
+    const aggregationKey = getAggregationKey(evt, selectorPath);
+    if (!!aggregationKey && aggregationKey === this.#aggregationKey) {
+      // an aggregation exists already, so lets just continue to increment
+      this.#aggregationEvent.aggregate(evt);
+    } else {
+      // return the prev existing one (if there is one)
+      const finishedEvent = this.#aggregationEvent;
+      // then set as this new event aggregation
+      this.#aggregationKey = aggregationKey;
+      this.#aggregationEvent = new _aggregatedUserAction.AggregatedUserAction(evt, selectorPath);
+      return finishedEvent;
+    }
+  }
+}
+
+/**
+ * Generates a selector path for the event, starting with simple cases like window or document and getting more complex for dom-tree traversals as needed.
+ * Will return a random selector path value if no other path can be determined, to force the aggregator to skip aggregation for this event.
+ * @param {Event} evt
+ * @returns {string}
+ */
+exports.UserActionsAggregator = UserActionsAggregator;
+function getSelectorPath(evt) {
+  let selectorPath;
+  if (_constants.OBSERVED_WINDOW_EVENTS.includes(evt.type) || evt.target === window) selectorPath = 'window';else if (evt.target === document) selectorPath = 'document';
+  // if still no selectorPath, generate one from target tree that includes elem ids
+  else selectorPath = (0, _selectorPath.generateSelectorPath)(evt.target);
+  // if STILL no selectorPath, it will return undefined which will skip aggregation for this event
+  return selectorPath;
+}
+
+/**
+ * Returns an aggregation key based on the event type and the selector path of the event's target.
+ * Scrollend events are aggregated into one set, no matter what.
+ * @param {Event} evt
+ * @param {string} selectorPath
+ * @returns {string}
+ */
+function getAggregationKey(evt, selectorPath) {
+  let aggregationKey = evt.type;
+  /** aggregate all scrollends into one set (if sequential), no matter what their target is
+   * the aggregation group's selector path with be reflected as the first one observed
+   * due to the way the aggregation logic works (by storing the initial value and aggregating it) */
+  if (evt.type !== 'scrollend') aggregationKey += '-' + selectorPath;
+  return aggregationKey;
+}

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

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

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

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

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

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

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

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

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

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

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;
@@ -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/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.268.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.268.0";
 
 /**
  * Exposes the build type of the agent