@newrelic/browser-agent 1.275.0 → 1.277.0

package/dist/cjs/features/soft_navigations/aggregate/interaction.js

@@ -18,8 +18,6 @@ var _belNode = require("./bel-node");
 class Interaction extends _belNode.BelNode {
   id = (0, _uniqueId.generateUuid)(); // unique id that is serialized and used to link interactions with errors
   initialPageURL = _runtime.initialLocation;
-  oldURL = '' + _runtime.globalScope?.location;
-  newURL = '' + _runtime.globalScope?.location;
   customName;
   customAttributes = {};
   customDataByApi = {};
@@ -34,7 +32,7 @@ class Interaction extends _belNode.BelNode {
   keepOpenUntilEndApi = false;
   onDone = [];
   cancellationTimer;
-  constructor(agentIdentifier, uiEvent, uiEventTimestamp, currentRouteKnown) {
+  constructor(agentIdentifier, uiEvent, uiEventTimestamp, currentRouteKnown, currentUrl) {
     super(agentIdentifier);
     this.belType = _constants.NODE_TYPE.INTERACTION;
     this.trigger = uiEvent;
@@ -43,6 +41,7 @@ class Interaction extends _belNode.BelNode {
     this.eventSubscription = new Map([['finished', []], ['cancelled', []]]);
     this.forceSave = this.forceIgnore = false;
     if (this.trigger === _constants.API_TRIGGER_NAME) this.createdByApi = true;
+    this.newURL = this.oldURL = currentUrl || _runtime.globalScope?.location.href;
   }
   updateDom(timestamp) {
     this.domTimestamp = timestamp || (0, _now.now)(); // default timestamp should be precise for accurate isActiveDuring calculations
@@ -62,6 +61,8 @@ class Interaction extends _belNode.BelNode {
   done(customEndTime) {
     // User could've mark this interaction--regardless UI or api started--as "don't close until .end() is called on it". Only .end provides a timestamp; the default flows do not.
     if (this.keepOpenUntilEndApi && customEndTime === undefined) return false;
+    // If interaction is already closed, this is a no-op. However, returning true lets startUIInteraction know that it CAN start a new interaction, as this one is done.
+    if (this.status !== _constants.INTERACTION_STATUS.IP) return true;
     this.onDone.forEach(apiProvidedCb => apiProvidedCb(this.customDataByApi)); // this interaction's .save or .ignore can still be set by these user provided callbacks for example
 
     if (this.forceIgnore) this.#cancel(); // .ignore() always has precedence over save actions
@@ -71,7 +72,6 @@ class Interaction extends _belNode.BelNode {
     return true;
   }
   #finish(customEndTime = 0) {
-    if (this.status !== _constants.INTERACTION_STATUS.IP) return; // disallow this call if the ixn is already done aka not in-progress
     clearTimeout(this.cancellationTimer);
     this.end = Math.max(this.domTimestamp, this.historyTimestamp, customEndTime);
     this.customAttributes = {
@@ -85,7 +85,6 @@ class Interaction extends _belNode.BelNode {
     callbacks.forEach(fn => fn());
   }
   #cancel() {
-    if (this.status !== _constants.INTERACTION_STATUS.IP) return; // disallow this call if the ixn is already done aka not in-progress
     clearTimeout(this.cancellationTimer);
     this.status = _constants.INTERACTION_STATUS.CAN;
 
@@ -102,7 +101,7 @@ class Interaction extends _belNode.BelNode {
    */
   isActiveDuring(timestamp) {
     if (this.status === _constants.INTERACTION_STATUS.IP) return this.start <= timestamp;
-    return this.status === _constants.INTERACTION_STATUS.FIN && this.start <= timestamp && this.end >= timestamp;
+    return this.status === _constants.INTERACTION_STATUS.FIN && this.start <= timestamp && this.end > timestamp;
   }
 
   // Following are virtual properties overridden by a subclass:
@@ -110,16 +109,17 @@ class Interaction extends _belNode.BelNode {
   get firstContentfulPaint() {}
   get navTiming() {}
   serialize(firstStartTimeOfPayload) {
+    const isFirstIxnOfPayload = firstStartTimeOfPayload === undefined;
     const addString = (0, _belSerializer.getAddStringContext)(this.agentIdentifier);
     const nodeList = [];
     let ixnType;
-    if (this.trigger === 'initialPageLoad') ixnType = _constants.INTERACTION_TYPE.INITIAL_PAGE_LOAD;else if (this.newURL !== this.oldURL) ixnType = _constants.INTERACTION_TYPE.ROUTE_CHANGE;else ixnType = _constants.INTERACTION_TYPE.UNSPECIFIED;
+    if (this.trigger === _constants.IPL_TRIGGER_NAME) ixnType = _constants.INTERACTION_TYPE.INITIAL_PAGE_LOAD;else if (this.newURL !== this.oldURL) ixnType = _constants.INTERACTION_TYPE.ROUTE_CHANGE;else ixnType = _constants.INTERACTION_TYPE.UNSPECIFIED;
 
     // IMPORTANT: The order in which addString is called matters and correlates to the order in which string shows up in the harvest payload. Do not re-order the following code.
     const fields = [(0, _belSerializer.numeric)(this.belType), 0,
     // this will be overwritten below with number of attached nodes
-    (0, _belSerializer.numeric)(this.start - firstStartTimeOfPayload),
-    // relative to first node
+    (0, _belSerializer.numeric)(this.start - (isFirstIxnOfPayload ? 0 : firstStartTimeOfPayload)),
+    // the very 1st ixn does not require offset so it should fallback to a 0 while rest is offset by the very 1st ixn's start
     (0, _belSerializer.numeric)(this.end - this.start),
     // end -- relative to start
     (0, _belSerializer.numeric)(this.callbackEnd),
@@ -130,9 +130,9 @@ class Interaction extends _belNode.BelNode {
     const allAttachedNodes = (0, _belSerializer.addCustomAttributes)(this.customAttributes || {}, addString); // start with all custom attributes
     if ((0, _info.getInfo)(this.agentIdentifier).atts) allAttachedNodes.push('a,' + addString((0, _info.getInfo)(this.agentIdentifier).atts)); // add apm provided attributes
     /* Querypack encoder+decoder quirkiness:
-       - If first ixn node of payload is being processed, we use this node's start to offset. (firstStartTime should be 0--or undefined.)
-       - Else for subsequent ixn nodes, we use the first ixn node's start to offset. */
-    this.children.forEach(node => allAttachedNodes.push(node.serialize(firstStartTimeOfPayload || this.start))); // recursively add the serialized string of every child of this (ixn) bel node
+       - If first ixn node of payload is being processed, its children's start time must be offset by this node's start. (firstStartTime should be undefined.)
+       - Else for subsequent ixns in the same payload, we go back to using that first ixn node's start to offset their children's start. */
+    this.children.forEach(node => allAttachedNodes.push(node.serialize(isFirstIxnOfPayload ? this.start : firstStartTimeOfPayload))); // recursively add the serialized string of every child of this (ixn) bel node
 
     fields[1] = (0, _belSerializer.numeric)(allAttachedNodes.length);
     nodeList.push(fields);

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

@@ -3,15 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.NODE_TYPE = exports.INTERACTION_TYPE = exports.INTERACTION_TRIGGERS = exports.INTERACTION_STATUS = exports.FEATURE_NAME = exports.API_TRIGGER_NAME = void 0;
+exports.NODE_TYPE = exports.IPL_TRIGGER_NAME = exports.INTERACTION_TYPE = exports.INTERACTION_TRIGGERS = exports.INTERACTION_STATUS = exports.FEATURE_NAME = exports.API_TRIGGER_NAME = void 0;
 var _features = require("../../loaders/features/features");
 const INTERACTION_TRIGGERS = exports.INTERACTION_TRIGGERS = ['click',
 // e.g. user clicks link or the page back/forward buttons
 'keydown',
 // e.g. user presses left and right arrow key to switch between displayed photo gallery
-'submit' // e.g. user clicks submit butotn or presses enter while editing a form field
+'submit',
+// e.g. user clicks submit butotn or presses enter while editing a form field
+'popstate' // history api is used to navigate back and forward
 ];
 const API_TRIGGER_NAME = exports.API_TRIGGER_NAME = 'api';
+const IPL_TRIGGER_NAME = exports.IPL_TRIGGER_NAME = 'initialPageLoad';
 const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.softNav;
 const INTERACTION_TYPE = exports.INTERACTION_TYPE = {
   INITIAL_PAGE_LOAD: '',

package/dist/cjs/loaders/api/api-methods.js

@@ -5,5 +5,5 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.asyncApiMethods = exports.apiMethods = void 0;
 var _constants = require("../../features/session_replay/constants");
-const apiMethods = exports.apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', _constants.SR_EVENT_EMITTER_TYPES.RECORD, _constants.SR_EVENT_EMITTER_TYPES.PAUSE, 'log', 'wrapLogger'];
+const apiMethods = exports.apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'recordCustomEvent', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', _constants.SR_EVENT_EMITTER_TYPES.RECORD, _constants.SR_EVENT_EMITTER_TYPES.PAUSE, 'log', 'wrapLogger'];
 const asyncApiMethods = exports.asyncApiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease'];

package/dist/cjs/loaders/api/api.js

@@ -80,6 +80,7 @@ function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
     apiInterface[fnName] = apiCall(prefix, fnName, true, 'api');
   });
   apiInterface.addPageAction = apiCall(prefix, 'addPageAction', true, _features.FEATURE_NAMES.genericEvents);
+  apiInterface.recordCustomEvent = apiCall(prefix, 'recordCustomEvent', true, _features.FEATURE_NAMES.genericEvents);
   apiInterface.setPageViewName = function (name, host) {
     if (typeof name !== 'string') return;
     if (name.charAt(0) !== '/') name = '/' + name;
@@ -198,7 +199,7 @@ function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
   function apiCall(prefix, name, notSpa, bufferGroup) {
     return function () {
       (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/' + name + '/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
-      if (bufferGroup) (0, _handle.handle)(prefix + name, [(0, _now.now)(), ...arguments], notSpa ? null : this, bufferGroup, instanceEE); // no bufferGroup means only the SM is emitted
+      if (bufferGroup) (0, _handle.handle)(prefix + name, [notSpa ? (0, _now.now)() : performance.now(), ...arguments], notSpa ? null : this, bufferGroup, instanceEE); // no bufferGroup means only the SM is emitted
       return notSpa ? undefined : this; // returns the InteractionHandle which allows these methods to be chained
     };
   }

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

@@ -33,6 +33,16 @@ class MicroAgentBase {
     return this.#callMethod('addPageAction', name, attributes);
   }
 
+  /**
+   * Records a custom event with a specified eventType and attributes.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/recordCustomEvent/}
+   * @param {string} eventType The eventType to store the event as.
+   * @param {object} [attributes] JSON object with one or more key/value pairs. For example: {key:"value"}.
+   */
+  recordCustomEvent(eventType, attributes) {
+    return this.#callMethod('recordCustomEvent', eventType, attributes);
+  }
+
   /**
    * Groups page views to help URL structure or to capture the URL's routing information.
    * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setpageviewname/}

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

@@ -1,3 +1,4 @@
+import { FEATURE_FLAGS } from '../../features/generic_events/constants';
 import { LOG_LEVELS } from '../../features/logging/constants';
 import { isValidSelector } from '../dom/query-selector';
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS } from '../session/constants';
@@ -7,6 +8,12 @@ import { getModeledObject } from './configurable';
 const nrMask = '[data-nr-mask]';
 const model = () => {
   const hiddenState = {
+    feature_flags: [],
+    experimental: {
+      marks: false,
+      measures: false,
+      resources: false
+    },
     mask_selector: '*',
     block_selector: '[data-nr-block]',
     mask_input_options: {
@@ -44,7 +51,12 @@ const model = () => {
       cors_use_tracecontext_headers: undefined,
       allowed_origins: undefined
     },
-    feature_flags: [],
+    get feature_flags() {
+      return hiddenState.feature_flags;
+    },
+    set feature_flags(val) {
+      hiddenState.feature_flags = val;
+    },
     generic_events: {
       enabled: true,
       harvestTimeSeconds: 30,
@@ -82,8 +94,32 @@ const model = () => {
       autoStart: true
     },
     performance: {
-      capture_marks: false,
-      capture_measures: false // false by default through experimental phase, but flipped to true once GA'd
+      get capture_marks() {
+        return hiddenState.feature_flags.includes(FEATURE_FLAGS.MARKS) || hiddenState.experimental.marks;
+      },
+      set capture_marks(val) {
+        hiddenState.experimental.marks = val;
+      },
+      get capture_measures() {
+        return hiddenState.feature_flags.includes(FEATURE_FLAGS.MEASURES) || hiddenState.experimental.measures;
+      },
+      set capture_measures(val) {
+        hiddenState.experimental.measures = val;
+      },
+      resources: {
+        // whether to run this subfeature or not in the generic_events feature. false by default through experimental phase, but flipped to true once GA'd
+        get enabled() {
+          return hiddenState.feature_flags.includes(FEATURE_FLAGS.RESOURCES) || hiddenState.experimental.resources;
+        },
+        set enabled(val) {
+          hiddenState.experimental.resources = val;
+        },
+        asset_types: [],
+        // MDN types to collect, empty array will collect all types
+        first_party_domains: [],
+        // when included, will decorate the resource as first party if matching
+        ignore_newrelic: true // ignore capturing internal agent scripts and harvest calls
+      }
     },
     privacy: {
       cookies_enabled: true

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.275.0";
+export const VERSION = "1.277.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.275.0";
+export const VERSION = "1.277.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -338,7 +338,7 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
     if (hasUndefinedHostname(params)) return; // don't bother with XHR of url with no hostname
 
     metrics.duration = now() - this.startTime;
-    if (!this.loadCazptureCalled && xhr.readyState === 4) {
+    if (!this.loadCaptureCalled && xhr.readyState === 4) {
       captureXhrData(this, xhr);
     } else if (params.status == null) {
       params.status = 0;

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

@@ -5,8 +5,8 @@
 import { stringify } from '../../../common/util/stringify';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { cleanURL } from '../../../common/url/clean-url';
-import { FEATURE_NAME } from '../constants';
-import { initialLocation, isBrowserScope } from '../../../common/constants/runtime';
+import { FEATURE_NAME, RESERVED_EVENT_TYPES } from '../constants';
+import { globalScope, initialLocation, isBrowserScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { warn } from '../../../common/util/console';
 import { now } from '../../../common/timing/now';
@@ -16,6 +16,7 @@ import { applyFnToProps } from '../../../common/util/traverse';
 import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features';
 import { UserActionsAggregator } from './user-actions/user-actions-aggregator';
 import { isIFrameWindow } from '../../../common/dom/iframe';
+import { handle } from '../../../common/event-emitter/handle';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
@@ -29,12 +30,21 @@ export class Aggregate extends AggregateBase {
         this.deregisterDrain();
         return;
       }
+      this.trackSupportabilityMetrics();
+      registerHandler('api-recordCustomEvent', (timestamp, eventType, attributes) => {
+        if (RESERVED_EVENT_TYPES.includes(eventType)) return warn(46);
+        this.addEvent({
+          eventType,
+          timestamp: this.toEpoch(timestamp),
+          ...attributes
+        });
+      }, this.featureName, this.ee);
       if (agentRef.init.page_action.enabled) {
         registerHandler('api-addPageAction', (timestamp, name, attributes) => {
           this.addEvent({
             ...attributes,
             eventType: 'PageAction',
-            timestamp: Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp)),
+            timestamp: this.toEpoch(timestamp),
             timeSinceLoad: timestamp / 1000,
             actionName: name,
             referrerUrl: this.referrerUrl,
@@ -60,7 +70,7 @@ export class Aggregate extends AggregateBase {
               } = aggregatedUserAction.event;
               this.addEvent({
                 eventType: 'UserAction',
-                timestamp: Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timeStamp)),
+                timestamp: this.toEpoch(timeStamp),
                 action: type,
                 actionCount: aggregatedUserAction.count,
                 actionDuration: aggregatedUserAction.relativeMs[aggregatedUserAction.relativeMs.length - 1],
@@ -70,19 +80,28 @@ export class Aggregate extends AggregateBase {
                 ...(isIFrameWindow(window) && {
                   iframe: true
                 }),
-                ...(target?.id && {
+                ...(canTrustTargetAttribute('id') && {
                   targetId: target.id
                 }),
-                ...(target?.tagName && {
+                ...(canTrustTargetAttribute('tagName') && {
                   targetTag: target.tagName
                 }),
-                ...(target?.type && {
+                ...(canTrustTargetAttribute('type') && {
                   targetType: target.type
                 }),
-                ...(target?.className && {
+                ...(canTrustTargetAttribute('className') && {
                   targetClass: target.className
                 })
               });
+
+              /**
+               * Only trust attributes that exist on HTML element targets, which excludes the window and the document targets
+               * @param {string} attribute The attribute to check for on the target element
+               * @returns {boolean} Whether the target element has the attribute and can be trusted
+               */
+              function canTrustTargetAttribute(attribute) {
+                return !!(aggregatedUserAction.selectorPath !== 'window' && aggregatedUserAction.selectorPath !== 'document' && target instanceof HTMLElement && target?.[attribute]);
+              }
             }
           } catch (e) {
             // do nothing for now
@@ -109,10 +128,11 @@ export class Aggregate extends AggregateBase {
               const observer = new PerformanceObserver(list => {
                 list.getEntries().forEach(entry => {
                   try {
+                    handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/Performance/' + type + '/Seen']);
                     this.addEvent({
                       eventType: 'BrowserPerformance',
-                      timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(entry.startTime)),
-                      entryName: entry.name,
+                      timestamp: this.toEpoch(entry.startTime),
+                      entryName: cleanURL(entry.name),
                       entryDuration: entry.duration,
                       entryType: type,
                       ...(entry.detail && {
@@ -132,6 +152,47 @@ export class Aggregate extends AggregateBase {
           // Something failed in our set up, likely the browser does not support PO's... do nothing
         }
       }
+      if (isBrowserScope && agentRef.init.performance.resources.enabled) {
+        registerHandler('browserPerformance.resource', entry => {
+          try {
+            // convert the entry to a plain object and separate the name and duration from the object
+            // you need to do this to be able to spread it into the addEvent call later, and name and duration
+            // would be duplicative of entryName and entryDuration and are protected keys in NR1
+            const {
+              name,
+              duration,
+              ...entryObject
+            } = entry.toJSON();
+            let firstParty = false;
+            try {
+              const entryDomain = new URL(name).hostname;
+              const isNr = entryDomain.includes('newrelic.com') || entryDomain.includes('nr-data.net') || entryDomain.includes('nr-local.net');
+              /** decide if we should ignore nr-specific assets */
+              if (this.agentRef.init.performance.resources.ignore_newrelic && isNr) return;
+              /** decide if we should ignore the asset type (empty means allow everything, which is the default) */
+              if (this.agentRef.init.performance.resources.asset_types.length && !this.agentRef.init.performance.resources.asset_types.includes(entryObject.initiatorType)) return;
+              /** decide if the entryDomain is a first party domain */
+              firstParty = entryDomain === globalScope?.location.hostname || agentRef.init.performance.resources.first_party_domains.includes(entryDomain);
+              if (firstParty) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/Performance/FirstPartyResource/Seen']);
+              if (isNr) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/Performance/NrResource/Seen']);
+            } catch (err) {
+              // couldnt parse the URL, so firstParty will just default to false
+            }
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Generic/Performance/Resource/Seen']);
+            const event = {
+              ...entryObject,
+              eventType: 'BrowserPerformance',
+              timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(entryObject.startTime)),
+              entryName: name,
+              entryDuration: duration,
+              firstParty
+            };
+            this.addEvent(event);
+          } catch (err) {
+            this.ee.emit('internal-error', [err, 'GenericEvents-Resource']);
+          }
+        }, this.featureName, this.ee);
+      }
       this.harvestScheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
         onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
         onUnload: () => addUserAction?.(this.userActionAggregator.aggregationEvent)
@@ -202,4 +263,17 @@ export class Aggregate extends AggregateBase {
       at: this.agentRef.info.atts
     };
   }
+  toEpoch(timestamp) {
+    return Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp));
+  }
+  trackSupportabilityMetrics() {
+    /** track usage SMs to improve these experimental features */
+    const configPerfTag = 'Config/Performance/';
+    if (this.agentRef.init.performance.capture_marks) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'CaptureMarks/Enabled']);
+    if (this.agentRef.init.performance.capture_measures) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'CaptureMeasures/Enabled']);
+    if (this.agentRef.init.performance.resources.enabled) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/Enabled']);
+    if (this.agentRef.init.performance.resources.asset_types?.length !== 0) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/AssetTypes/Changed']);
+    if (this.agentRef.init.performance.resources.first_party_domains?.length !== 0) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/FirstPartyDomains/Changed']);
+    if (this.agentRef.init.performance.resources.ignore_newrelic === false) handle(SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/IgnoreNewrelic/Changed']);
+  }
 }

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

@@ -5,4 +5,10 @@ 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;
+export const RAGE_CLICK_THRESHOLD_MS = 1000;
+export const RESERVED_EVENT_TYPES = ['PageAction', 'UserAction', 'BrowserPerformance'];
+export const FEATURE_FLAGS = {
+  MARKS: 'experimental.marks',
+  MEASURES: 'experimental.measures',
+  RESOURCES: 'experimental.resources'
+};

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

@@ -2,7 +2,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { isBrowserScope } from '../../../common/constants/runtime';
+import { globalScope, isBrowserScope } from '../../../common/constants/runtime';
 import { handle } from '../../../common/event-emitter/handle';
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
 import { InstrumentBase } from '../../utils/instrument-base';
@@ -11,14 +11,26 @@ export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef, auto = true) {
     super(agentRef, FEATURE_NAME, auto);
-    const genericEventSourceConfigs = [agentRef.init.page_action.enabled, agentRef.init.performance.capture_marks, agentRef.init.performance.capture_measures, agentRef.init.user_actions.enabled
-    // other future generic event source configs to go here, like M&Ms, PageResouce, etc.
-    ];
-    if (isBrowserScope && agentRef.init.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.
-      );
+    /** config values that gate whether the generic events aggregator should be imported at all */
+    const genericEventSourceConfigs = [agentRef.init.page_action.enabled, agentRef.init.performance.capture_marks, agentRef.init.performance.capture_measures, agentRef.init.user_actions.enabled, agentRef.init.performance.resources.enabled];
+    if (isBrowserScope) {
+      if (agentRef.init.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 (agentRef.init.performance.resources.enabled && globalScope.PerformanceObserver?.supportedEntryTypes.includes('resource')) {
+        const observer = new PerformanceObserver(list => {
+          list.getEntries().forEach(entry => {
+            handle('browserPerformance.resource', [entry], undefined, this.featureName, this.ee);
+          });
+        });
+        observer.observe({
+          type: 'resource',
+          buffered: true
+        });
+      }
     }
 
     /** If any of the sources are active, import the aggregator. otherwise deregister */

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

@@ -107,9 +107,10 @@ export class Aggregate extends AggregateBase {
    * @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
+   * @param {string=} swallowReason a string indicating pre-defined reason if swallowing the error.  Mainly used by the internal error SMs.
    * @returns
    */
-  storeError(err, time, internal, customAttributes, hasReplay) {
+  storeError(err, time, internal, customAttributes, hasReplay, swallowReason) {
     if (!err) return;
     // are we in an interaction
     time = time || now();
@@ -127,7 +128,7 @@ export class Aggregate extends AggregateBase {
     const {
       shouldSwallow,
       reason
-    } = evaluateInternalError(stackInfo, internal);
+    } = evaluateInternalError(stackInfo, internal, swallowReason);
     if (shouldSwallow) {
       handle(SUPPORTABILITY_METRIC_CHANNEL, ['Internal/Error/' + reason], undefined, FEATURE_NAMES.metrics, this.ee);
       return;

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

@@ -5,10 +5,10 @@ const REASON_SECURITY_POLICY = 'Security-Policy';
  * @param {Object} stackInfo - The error stack information.
  * @returns {boolean} - Whether the error should be swallowed or not.
  */
-export function evaluateInternalError(stackInfo, internal) {
+export function evaluateInternalError(stackInfo, internal, reason) {
   const output = {
     shouldSwallow: internal || false,
-    reason: 'Other'
+    reason: 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 */

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

@@ -20,9 +20,9 @@ export class Instrument extends InstrumentBase {
       // this try-catch can be removed when IE11 is completely unsupported & gone
       this.removeOnAbort = new AbortController();
     } catch (e) {}
-    this.ee.on('internal-error', error => {
+    this.ee.on('internal-error', (error, reason) => {
       if (!this.abortHandler) return;
-      handle('ierr', [castError(error), now(), true, {}, this.#replayRunning], undefined, this.featureName, this.ee);
+      handle('ierr', [castError(error), now(), true, {}, this.#replayRunning, reason], undefined, this.featureName, this.ee);
     });
     this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
       this.#replayRunning = isRunning;

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

@@ -148,40 +148,6 @@ export class Aggregate extends AggregateBase {
     });
   }
   unload() {
-    try {
-      if (this.resourcesSent) return;
-      this.resourcesSent = true; // make sure this only gets sent once
-
-      // Capture SMs around network resources using the performance API to assess
-      // work to split this out from the ST nodes
-      // differentiate between internal+external and ajax+non-ajax
-      const ajaxResources = ['beacon', 'fetch', 'xmlhttprequest'];
-      const internalUrls = ['nr-data.net', 'newrelic.com', 'nr-local.net', 'localhost'];
-      function isInternal(x) {
-        return internalUrls.some(y => x.name.indexOf(y) >= 0);
-      }
-      function isAjax(x) {
-        return ajaxResources.includes(x.initiatorType);
-      }
-      const allResources = performance?.getEntriesByType('resource') || [];
-      allResources.forEach(entry => {
-        if (isInternal(entry)) {
-          if (isAjax(entry)) this.storeSupportabilityMetrics('Generic/Resources/Ajax/Internal');else this.storeSupportabilityMetrics('Generic/Resources/Non-Ajax/Internal');
-        } else {
-          if (isAjax(entry)) this.storeSupportabilityMetrics('Generic/Resources/Ajax/External');else this.storeSupportabilityMetrics('Generic/Resources/Non-Ajax/External');
-        }
-      });
-
-      // Capture SMs for performance markers and measures to assess the usage and possible inclusion of this
-      // data in the agent for use in NR
-      if (typeof performance !== 'undefined') {
-        const markers = performance.getEntriesByType('mark');
-        const measures = performance.getEntriesByType('measure');
-        if (markers.length) this.storeSupportabilityMetrics('Generic/Performance/Mark/Seen', markers.length);
-        if (measures.length) this.storeSupportabilityMetrics('Generic/Performance/Measure/Seen', measures.length);
-      }
-    } catch (e) {
-      // do nothing
-    }
+    // do nothing for now, marks and measures and resources stats are now being captured by the ge feature
   }
 }