@newrelic/browser-agent 1.275.0 → 1.277.0

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.277.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.276.0...v1.277.0) (2024-12-18)
+
+
+### Features
+
+* Add custom events API ([#1263](https://github.com/newrelic/newrelic-browser-agent/issues/1263)) ([9395415](https://github.com/newrelic/newrelic-browser-agent/commit/9395415d942b55e88e89438aa203c6a1642d9e6b))
+
+
+### Bug Fixes
+
+* Soft navigation bug fixes and new soft navigation tests ([#1268](https://github.com/newrelic/newrelic-browser-agent/issues/1268)) ([7624928](https://github.com/newrelic/newrelic-browser-agent/commit/762492896a7b96564269aab1aadeb6e44a4da242))
+
+## [1.276.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.275.0...v1.276.0) (2024-12-16)
+
+
+### Features
+
+* allow feature flags to control experimental features ([#1282](https://github.com/newrelic/newrelic-browser-agent/issues/1282)) ([537e72d](https://github.com/newrelic/newrelic-browser-agent/commit/537e72da0821792006abd16c41ffa025fd73b474))
+* Capture Page Resource Assets ([#1257](https://github.com/newrelic/newrelic-browser-agent/issues/1257)) ([e4c7deb](https://github.com/newrelic/newrelic-browser-agent/commit/e4c7debe2a1653efdad8940c55a71dd0140ce900))
+
+
+### Bug Fixes
+
+* Fix syntax error in fallback when tracking xhr readyState ([#1272](https://github.com/newrelic/newrelic-browser-agent/issues/1272)) ([2bb6b5b](https://github.com/newrelic/newrelic-browser-agent/commit/2bb6b5b2e104a6b3ac9ceb70d396f65cfb61c1bd))
+* Ignore reserved attribute names on UserActions tied to the window ([#1261](https://github.com/newrelic/newrelic-browser-agent/issues/1261)) ([8410dbe](https://github.com/newrelic/newrelic-browser-agent/commit/8410dbeef30aeb0e578c63a293ec311c3d42f8da))
+
 ## [1.275.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.274.0...v1.275.0) (2024-12-03)
 
 

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

@@ -6,15 +6,22 @@ Object.defineProperty(exports, "__esModule", {
 exports.getConfiguration = getConfiguration;
 exports.getConfigurationValue = getConfigurationValue;
 exports.setConfiguration = setConfiguration;
-var _constants = require("../../features/logging/constants");
+var _constants = require("../../features/generic_events/constants");
+var _constants2 = require("../../features/logging/constants");
 var _querySelector = require("../dom/query-selector");
-var _constants2 = require("../session/constants");
+var _constants3 = require("../session/constants");
 var _console = require("../util/console");
 var _nreum = require("../window/nreum");
 var _configurable = require("./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: {
@@ -52,7 +59,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,
@@ -70,7 +82,7 @@ const model = () => {
       enabled: true,
       harvestTimeSeconds: 10,
       autoStart: true,
-      level: _constants.LOG_LEVELS.INFO
+      level: _constants2.LOG_LEVELS.INFO
     },
     metrics: {
       enabled: true,
@@ -90,8 +102,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(_constants.FEATURE_FLAGS.MARKS) || hiddenState.experimental.marks;
+      },
+      set capture_marks(val) {
+        hiddenState.experimental.marks = val;
+      },
+      get capture_measures() {
+        return hiddenState.feature_flags.includes(_constants.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(_constants.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
@@ -103,8 +139,8 @@ const model = () => {
       beacon: undefined // likewise for the url to which we send analytics
     },
     session: {
-      expiresMs: _constants2.DEFAULT_EXPIRES_MS,
-      inactiveMs: _constants2.DEFAULT_INACTIVE_MS
+      expiresMs: _constants3.DEFAULT_EXPIRES_MS,
+      inactiveMs: _constants3.DEFAULT_INACTIVE_MS
     },
     session_replay: {
       // feature settings

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.275.0";
+const VERSION = exports.VERSION = "1.277.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.275.0";
+const VERSION = exports.VERSION = "1.277.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -346,7 +346,7 @@ function subscribeToEvents(agentRef, ee, handler, dt) {
     if ((0, _denyList.hasUndefinedHostname)(params)) return; // don't bother with XHR of url with no hostname
 
     metrics.duration = (0, _now.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/cjs/features/generic_events/aggregate/index.js

@@ -18,6 +18,7 @@ var _traverse = require("../../../common/util/traverse");
 var _features = require("../../../loaders/features/features");
 var _userActionsAggregator = require("./user-actions/user-actions-aggregator");
 var _iframe = require("../../../common/dom/iframe");
+var _handle = require("../../../common/event-emitter/handle");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -36,12 +37,21 @@ class Aggregate extends _aggregateBase.AggregateBase {
         this.deregisterDrain();
         return;
       }
+      this.trackSupportabilityMetrics();
+      (0, _registerHandler.registerHandler)('api-recordCustomEvent', (timestamp, eventType, attributes) => {
+        if (_constants.RESERVED_EVENT_TYPES.includes(eventType)) return (0, _console.warn)(46);
+        this.addEvent({
+          eventType,
+          timestamp: this.toEpoch(timestamp),
+          ...attributes
+        });
+      }, this.featureName, this.ee);
       if (agentRef.init.page_action.enabled) {
         (0, _registerHandler.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,
@@ -67,7 +77,7 @@ class Aggregate extends _aggregateBase.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],
@@ -77,19 +87,28 @@ class Aggregate extends _aggregateBase.AggregateBase {
                 ...((0, _iframe.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
@@ -116,10 +135,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
               const observer = new PerformanceObserver(list => {
                 list.getEntries().forEach(entry => {
                   try {
+                    (0, _handle.handle)(_constants2.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: (0, _cleanUrl.cleanURL)(entry.name),
                       entryDuration: entry.duration,
                       entryType: type,
                       ...(entry.detail && {
@@ -139,6 +159,47 @@ class Aggregate extends _aggregateBase.AggregateBase {
           // Something failed in our set up, likely the browser does not support PO's... do nothing
         }
       }
+      if (_runtime.isBrowserScope && agentRef.init.performance.resources.enabled) {
+        (0, _registerHandler.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 === _runtime.globalScope?.location.hostname || agentRef.init.performance.resources.first_party_domains.includes(entryDomain);
+              if (firstParty) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Generic/Performance/FirstPartyResource/Seen']);
+              if (isNr) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Generic/Performance/NrResource/Seen']);
+            } catch (err) {
+              // couldnt parse the URL, so firstParty will just default to false
+            }
+            (0, _handle.handle)(_constants2.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.HarvestScheduler(_features.FEATURE_TO_ENDPOINT[this.featureName], {
         onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
         onUnload: () => addUserAction?.(this.userActionAggregator.aggregationEvent)
@@ -209,5 +270,18 @@ class Aggregate extends _aggregateBase.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) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'CaptureMarks/Enabled']);
+    if (this.agentRef.init.performance.capture_measures) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'CaptureMeasures/Enabled']);
+    if (this.agentRef.init.performance.resources.enabled) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/Enabled']);
+    if (this.agentRef.init.performance.resources.asset_types?.length !== 0) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/AssetTypes/Changed']);
+    if (this.agentRef.init.performance.resources.first_party_domains?.length !== 0) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/FirstPartyDomains/Changed']);
+    if (this.agentRef.init.performance.resources.ignore_newrelic === false) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, [configPerfTag + 'Resources/IgnoreNewrelic/Changed']);
+  }
 }
 exports.Aggregate = Aggregate;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-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;
+exports.RESERVED_EVENT_TYPES = 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 = exports.FEATURE_FLAGS = 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;
@@ -11,4 +11,10 @@ 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;
+const RAGE_CLICK_THRESHOLD_MS = exports.RAGE_CLICK_THRESHOLD_MS = 1000;
+const RESERVED_EVENT_TYPES = exports.RESERVED_EVENT_TYPES = ['PageAction', 'UserAction', 'BrowserPerformance'];
+const FEATURE_FLAGS = exports.FEATURE_FLAGS = {
+  MARKS: 'experimental.marks',
+  MEASURES: 'experimental.measures',
+  RESOURCES: 'experimental.resources'
+};

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

@@ -17,14 +17,26 @@ class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentRef, auto = true) {
     super(agentRef, _constants.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 (_runtime.isBrowserScope && agentRef.init.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.
-      );
+    /** 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 (_runtime.isBrowserScope) {
+      if (agentRef.init.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 (agentRef.init.performance.resources.enabled && _runtime.globalScope.PerformanceObserver?.supportedEntryTypes.includes('resource')) {
+        const observer = new PerformanceObserver(list => {
+          list.getEntries().forEach(entry => {
+            (0, _handle.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/cjs/features/jserrors/aggregate/index.js

@@ -112,9 +112,10 @@ class Aggregate extends _aggregateBase.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 || (0, _now.now)();
@@ -132,7 +133,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     const {
       shouldSwallow,
       reason
-    } = (0, _internalErrors.evaluateInternalError)(stackInfo, internal);
+    } = (0, _internalErrors.evaluateInternalError)(stackInfo, internal, swallowReason);
     if (shouldSwallow) {
       (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Internal/Error/' + reason], undefined, _features.FEATURE_NAMES.metrics, this.ee);
       return;

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

@@ -11,10 +11,10 @@ const REASON_SECURITY_POLICY = 'Security-Policy';
  * @param {Object} stackInfo - The error stack information.
  * @returns {boolean} - Whether the error should be swallowed or not.
  */
-function evaluateInternalError(stackInfo, internal) {
+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/cjs/features/jserrors/instrument/index.js

@@ -26,9 +26,9 @@ class Instrument extends _instrumentBase.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;
-      (0, _handle.handle)('ierr', [(0, _castError.castError)(error), (0, _now.now)(), true, {}, this.#replayRunning], undefined, this.featureName, this.ee);
+      (0, _handle.handle)('ierr', [(0, _castError.castError)(error), (0, _now.now)(), true, {}, this.#replayRunning, reason], undefined, this.featureName, this.ee);
     });
     this.ee.on(_constants2.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
       this.#replayRunning = isRunning;

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

@@ -154,41 +154,7 @@ class Aggregate extends _aggregateBase.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
   }
 }
 exports.Aggregate = Aggregate;

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

@@ -26,20 +26,23 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.interactionsToHarvest = this.events;
     this.domObserver = domObserver;
     this.initialPageLoadInteraction = new _initialPageLoadInteraction.InitialPageLoadInteraction(agentRef.agentIdentifier);
+    this.initialPageLoadInteraction.onDone.push(() => {
+      // this ensures the .end() method also works with iPL
+      this.initialPageLoadInteraction.forceSave = true; // unless forcibly ignored, iPL always finish by default
+      this.interactionsToHarvest.add(this.initialPageLoadInteraction);
+      this.initialPageLoadInteraction = null;
+    });
     _timeToFirstByte.timeToFirstByte.subscribe(({
       attrs
     }) => {
       const loadEventTime = attrs.navigationEntry.loadEventEnd;
-      this.initialPageLoadInteraction.forceSave = true;
       this.initialPageLoadInteraction.done(loadEventTime);
-      this.interactionsToHarvest.add(this.initialPageLoadInteraction);
-      this.initialPageLoadInteraction = null;
       // Report metric on the initial page load time
       (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['SoftNav/Interaction/InitialPageLoad/Duration/Ms', Math.round(loadEventTime)], undefined, _features.FEATURE_NAMES.metrics, this.ee);
     });
     this.latestRouteSetByApi = null;
     this.interactionInProgress = null; // aside from the "page load" interaction, there can only ever be 1 ongoing at a time
-
+    this.latestHistoryUrl = null;
     this.blocked = false;
     this.waitForFlags(['spa']).then(([spaOn]) => {
       if (spaOn) {
@@ -59,7 +62,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
     // By default, a complete UI driven interaction requires event -> URL change -> DOM mod in that exact order.
     (0, _registerHandler.registerHandler)('newUIEvent', event => this.startUIInteraction(event.type, Math.floor(event.timeStamp), event.target), this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('newURL', (timestamp, url) => this.interactionInProgress?.updateHistory(timestamp, url), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('newURL', (timestamp, url) => {
+      // In the case of 'popstate' trigger, by the time the event fires, the URL has already changed, so we need to store what-will-be the *previous* URL for oldURL of next popstate ixn.
+      this.latestHistoryUrl = url;
+      this.interactionInProgress?.updateHistory(timestamp, url);
+    }, this.featureName, this.ee);
     (0, _registerHandler.registerHandler)('newDom', timestamp => {
       this.interactionInProgress?.updateDom(timestamp);
       if (this.interactionInProgress?.seenHistoryAndDomChange()) this.interactionInProgress.done();
@@ -71,20 +78,23 @@ class Aggregate extends _aggregateBase.AggregateBase {
   serializer(eventBuffer) {
     // The payload depacker takes the first ixn of a payload (if there are multiple ixns) and positively offset the subsequent ixns timestamps by that amount.
     // In order to accurately portray the real start & end times of the 2nd & onward ixns, we hence need to negatively offset their start timestamps with that of the 1st ixn.
-    let firstIxnStartTime = 0; // the very 1st ixn does not require any offsetting
+    let firstIxnStartTime;
     const serializedIxnList = [];
     for (const interaction of eventBuffer) {
       serializedIxnList.push(interaction.serialize(firstIxnStartTime));
-      if (!firstIxnStartTime) firstIxnStartTime = Math.floor(interaction.start);
+      if (firstIxnStartTime === undefined) firstIxnStartTime = Math.floor(interaction.start); // careful not to match or overwrite on 0 value!
     }
     return "bel.7;".concat(serializedIxnList.join(';'));
   }
   startUIInteraction(eventName, startedAt, sourceElem) {
     // this is throttled by instrumentation so that it isn't excessively called
     if (this.interactionInProgress?.createdByApi) return; // api-started interactions cannot be disrupted aka cancelled by UI events (and the vice versa applies as well)
-    if (this.interactionInProgress?.done() === false) return;
-    this.interactionInProgress = new _interaction.Interaction(this.agentIdentifier, eventName, startedAt, this.latestRouteSetByApi);
-    if (eventName === 'click') {
+    if (this.interactionInProgress?.done() === false) return; // current in-progress is blocked from closing, e.g. by 'waitForEnd' api option
+
+    const oldURL = eventName === _constants2.INTERACTION_TRIGGERS[3] ? this.latestHistoryUrl : undefined; // see related comment in 'newURL' handler above, 'popstate'
+    this.interactionInProgress = new _interaction.Interaction(this.agentIdentifier, eventName, startedAt, this.latestRouteSetByApi, oldURL);
+    if (eventName === _constants2.INTERACTION_TRIGGERS[0]) {
+      // 'click'
       const sourceElemText = getActionText(sourceElem);
       if (sourceElemText) this.interactionInProgress.customAttributes.actionText = sourceElemText;
     }
@@ -130,7 +140,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       // reverse search for the latest completed interaction for efficiency
       const finishedInteraction = interactionsBuffer[idx];
       if (finishedInteraction.isActiveDuring(timestamp)) {
-        if (finishedInteraction.trigger !== 'initialPageLoad') return finishedInteraction;
+        if (finishedInteraction.trigger !== _constants2.IPL_TRIGGER_NAME) return finishedInteraction;
         // It's possible that a complete interaction occurs before page is fully loaded, so we need to consider if a route-change ixn may have overlapped this iPL
         else saveIxn = finishedInteraction;
       }
@@ -194,9 +204,16 @@ class Aggregate extends _aggregateBase.AggregateBase {
       // In here, 'this' refers to the EventContext specific to per InteractionHandle instance spawned by each .interaction() api call.
       // Each api call aka IH instance would therefore retain a reference to either the in-progress interaction *at the time of the call* OR a new api-started interaction.
       this.associatedInteraction = thisClass.getInteractionFor(time);
+      if (this.associatedInteraction?.trigger === _constants2.IPL_TRIGGER_NAME) this.associatedInteraction = null; // the api get-interaction method cannot target IPL
       if (!this.associatedInteraction) {
         // This new api-driven interaction will be the target of any subsequent .interaction() call, until it is closed by EITHER .end() OR the regular seenHistoryAndDomChange process.
         this.associatedInteraction = thisClass.interactionInProgress = new _interaction.Interaction(thisClass.agentIdentifier, _constants2.API_TRIGGER_NAME, time, thisClass.latestRouteSetByApi);
+        thisClass.domObserver.observe(document.body, {
+          attributes: true,
+          childList: true,
+          subtree: true,
+          characterData: true
+        }); // start observing for DOM changes like a regular UI-driven interaction
         thisClass.setClosureHandlers();
       }
       if (waitForEnd === true) this.associatedInteraction.keepOpenUntilEndApi = true;

package/dist/cjs/features/soft_navigations/aggregate/initial-page-load-interaction.js

@@ -10,9 +10,10 @@ var _belSerializer = require("../../../common/serialize/bel-serializer");
 var _firstPaint = require("../../../common/vitals/first-paint");
 var _firstContentfulPaint = require("../../../common/vitals/first-contentful-paint");
 var _info = require("../../../common/config/info");
+var _constants = require("../constants");
 class InitialPageLoadInteraction extends _interaction.Interaction {
   constructor(agentIdentifier) {
-    super(agentIdentifier, 'initialPageLoad', 0, null);
+    super(agentIdentifier, _constants.IPL_TRIGGER_NAME, 0, null);
     const agentInfo = (0, _info.getInfo)(agentIdentifier);
     this.queueTime = agentInfo.queueTime;
     this.appTime = agentInfo.applicationTime;