@newrelic/browser-agent 1.267.0 → 1.269.0

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.269.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.268.0...v1.269.0) (2024-10-16)
+
+
+### Features
+
+* Add instrumentation metadata to logging ([#1208](https://github.com/newrelic/newrelic-browser-agent/issues/1208)) ([6926474](https://github.com/newrelic/newrelic-browser-agent/commit/6926474fe2530475e10daab2bb6bad745bb547e1))
+* Include logging feature in micro agent loader ([#1210](https://github.com/newrelic/newrelic-browser-agent/issues/1210)) ([1b24484](https://github.com/newrelic/newrelic-browser-agent/commit/1b2448498cf285f36530f2107cb0403401958b1f))
+
+
+### Bug Fixes
+
+* Handle Session Replay Security Policy Errors ([#1215](https://github.com/newrelic/newrelic-browser-agent/issues/1215)) ([f14b0fe](https://github.com/newrelic/newrelic-browser-agent/commit/f14b0fec81d7d21b418b6be6c5d415bdd813eca9))
+* Only ever allow session traces to capture page load timings once ([#1212](https://github.com/newrelic/newrelic-browser-agent/issues/1212)) ([d189686](https://github.com/newrelic/newrelic-browser-agent/commit/d1896869858eca3320144113e168f17f524f3119))
+
+## [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/README.md

@@ -238,7 +238,8 @@ A lot of new frameworks support the concept of server-side rendering the pages o
 
 ## Disclaimers
 
-The session replay library shipping as part of the browser agent is not turned on by default. For information on the use of this feature, see [Session Replay](#session-replay)
+* The session replay feature is not turned on by default. For information on the use of this feature, see [Session Replay](#session-replay)
+* As part of the improvement efforts around our SPA capabilities, the `createTracer` API has been [deprecated](https://docs.newrelic.com/eol/2024/04/eol-04-24-24-createtracer/). Please engage in removing usage of that library. If tracking task duration, we recommend utilizing the generic browser performance mark and measure APIs, which will gain native detection support from the agent in a future update.
 
 ## Support
 

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.269.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.269.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

@@ -23,6 +23,8 @@ var _nreum = require("../../../common/window/nreum");
 var _drain = require("../../../common/drain/drain");
 var _now = require("../../../common/timing/now");
 var _traverse = require("../../../common/util/traverse");
+var _internalErrors = require("./internal-errors");
+var _constants2 = require("../../metrics/constants");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -130,6 +132,16 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     return canonicalStackString;
   }
+
+  /**
+   *
+   * @param {Error|UncaughtError} err The error instance to be processed
+   * @param {number} time the relative ms (to origin) timestamp of occurence
+   * @param {boolean=} internal if the error was "caught" and deemed "internal" before reporting to the jserrors feature
+   * @param {object=} customAttributes  any custom attributes to be included in the error payload
+   * @param {boolean=} hasReplay a flag indicating if the error occurred during a replay session
+   * @returns
+   */
   storeError(err, time, internal, customAttributes, hasReplay) {
     if (!err) return;
     // are we in an interaction
@@ -146,6 +158,14 @@ class Aggregate extends _aggregateBase.AggregateBase {
       // Again as with previous usage, all falsey values would include the error.
     }
     var stackInfo = (0, _computeStackTrace.computeStackTrace)(err);
+    const {
+      shouldSwallow,
+      reason
+    } = (0, _internalErrors.evaluateInternalError)(stackInfo, internal);
+    if (shouldSwallow) {
+      (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Internal/Error/' + reason], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+      return;
+    }
     var canonicalStackString = this.buildCanonicalStackString(stackInfo);
     const params = {
       stackHash: (0, _stringHashCode.stringHashCode)(canonicalStackString),
@@ -167,7 +187,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,8 +203,8 @@ 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)));
-    var type = internal ? 'ierr' : 'err';
+    params.timestamp = Math.floor(agentRuntime.timeKeeper.correctRelativeTimestamp(time));
+    var type = 'err';
     var newMetrics = {
       time
     };

package/dist/cjs/features/jserrors/aggregate/internal-errors.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evaluateInternalError = evaluateInternalError;
+const REASON_RRWEB = 'Rrweb';
+const REASON_SECURITY_POLICY = 'Security-Policy';
+/**
+ * This function is responsible for determining if an error should be swallowed or not.
+ * @param {Object} stackInfo - The error stack information.
+ * @returns {boolean} - Whether the error should be swallowed or not.
+ */
+function evaluateInternalError(stackInfo, internal) {
+  const output = {
+    shouldSwallow: internal || false,
+    reason: 'Other'
+  };
+  const leadingFrame = stackInfo.frames?.[0];
+  /** If we cant otherwise determine from the frames and message, the default of internal + reason will be the fallback */
+  if (!leadingFrame || typeof stackInfo?.message !== 'string') return output;
+
+  // check if the error happened in expected modules or if messages match known patterns
+  const isNrRecorder = leadingFrame?.url?.match(/nr-(.*)-recorder.min.js/);
+  const isRrweb = leadingFrame?.url?.match(/rrweb/);
+  const isMaybeNrRecorder = leadingFrame?.url?.match(/recorder/);
+  const isSecurityPolicyAPIError = stackInfo.message.toLowerCase().match(/an attempt was made to break through the security policy of the user agent/);
+
+  // check if modules and patterns above fit known swallow cases
+  if (!!isNrRecorder || !!isRrweb) {
+    /** We know -for sure- that the error came from our recorder module or rrweb directly if these are true, so swallow it */
+    output.shouldSwallow = true;
+    output.reason = REASON_RRWEB;
+    if (isSecurityPolicyAPIError) output.reason += '-' + REASON_SECURITY_POLICY;
+  } else if (!!isMaybeNrRecorder && isSecurityPolicyAPIError) {
+    /** We -suspect- that the error came from NR, so if it matches the exact case we know about, swallow it */
+    output.shouldSwallow = true;
+    output.reason = REASON_RRWEB + '-' + REASON_SECURITY_POLICY;
+  }
+  // other swallow conditions could also be added here
+  return output;
+}

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)) {
@@ -84,6 +84,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
   }
   prepareHarvest(options = {}) {
     if (this.blocked || !this.bufferedLogs.hasData) return;
+    /** These attributes are evaluated and dropped at ingest processing time and do not get stored on NRDB */
+    const unbilledAttributes = {
+      'instrumentation.provider': 'browser',
+      'instrumentation.version': this.#agentRuntime.version,
+      'instrumentation.name': this.#agentRuntime.loaderType
+    };
     /** see https://source.datanerd.us/agents/rum-specs/blob/main/browser/Log for logging spec */
     const payload = {
       qs: {
@@ -107,7 +113,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
             // Application ID from info object,
             standalone: Boolean(this.#agentInfo.sa),
             // copy paste (true) vs APM (false)
-            agentVersion: this.#agentRuntime.version // browser agent version
+            agentVersion: this.#agentRuntime.version,
+            // browser agent version,
+            ...unbilledAttributes
           }
         },
         /** logs section contains individual unique log entries */