@newrelic/browser-agent 1.237.0 → 1.238.0

package/dist/cjs/loaders/api/interaction-types.js

@@ -12,7 +12,7 @@ exports.unused = void 0;
  * @property {getContext} getContext
  * @property {ignore} ignore
  * @property {onEnd} onEnd
- * @property {onEnd} save
+ * @property {save} save
  * @property {setAttribute} setAttribute
  * @property {setName} setName
  */
@@ -30,8 +30,8 @@ exports.unused = void 0;
  * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/createtracer/}
  * @callback createTracer
  * @param {string} name This will be used as the name of the tracer.
- * @param {string} [callback] A callback that contains the synchronous work to run at the end of the async work. To execute this callback, call the wrapper function returned using createTracer().
- * @returns {Function} Returns a method that wraps the original callback. When this method is invoked, it calls the original callback and ends the async timing.
+ * @param {(...args: any[]) => any} [callback] A callback that contains the synchronous work to run at the end of the async work. To execute this callback, call the wrapper function returned using createTracer().
+ * @returns {(...args: any[]) => any} Returns a method that wraps the original callback. When this method is invoked, it calls the original callback and ends the async timing.
  */
 
 /**
@@ -49,6 +49,13 @@ exports.unused = void 0;
  * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
  */
 
+/**
+ * Overrides other SPA save() calls; ignores an interaction so it is not saved or sent to New Relic.
+ * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/ignore/}
+ * @callback ignore
+ * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
+ */
+
 /**
  * Change the values associated with a SPA interaction before the interaction is saved.
  * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/onend/}
@@ -69,7 +76,7 @@ exports.unused = void 0;
  * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setattribute/}
  * @callback setAttribute
  * @param {string} key Used as the attribute name on the BrowserInteraction event.
- * @param {any} key Used as the attribute value on the BrowserInteraction event. This can be a string, number, boolean, or object. If it is an object, New Relic serializes it to a JSON string.
+ * @param {any} value Used as the attribute value on the BrowserInteraction event. This can be a string, number, boolean, or object. If it is an object, New Relic serializes it to a JSON string.
  * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
  */
 

package/dist/cjs/loaders/configure/configure.js

@@ -36,7 +36,8 @@ function configure(agentIdentifier) {
     info.jsAttributes.isWorker = true;
   }
   (0, _config.setInfo)(agentIdentifier, info);
-  runtime.denyList = init.ajax?.block_internal ? (init.ajax.deny_list || []).concat(info.beacon, info.errorBeacon) : init.ajax?.deny_list;
+  const updatedInit = (0, _config.getConfiguration)(agentIdentifier);
+  runtime.denyList = [...(updatedInit.ajax?.deny_list || []), ...(updatedInit.ajax?.block_internal ? [info.beacon, info.errorBeacon] : [])];
   (0, _config.setRuntime)(agentIdentifier, runtime);
   (0, _api.setTopLevelCallers)();
   const api = (0, _api.setAPI)(agentIdentifier, forceDrain);

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.237.0";
+export const VERSION = "1.238.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.237.0";
+export const VERSION = "1.238.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/deny-list/deny-list.js

@@ -57,7 +57,7 @@ export function setDenyList(denyListConfig) {
       host = url;
       pathname = '';
     }
-    let [hostname, port] = host.split(':');
+    let [hostname] = host.split(':');
     denyList.push({
       hostname,
       pathname

package/dist/esm/common/event-emitter/contextual-ee.js

@@ -5,21 +5,21 @@
 
 import { gosNREUM } from '../window/nreum';
 import { getOrSet } from '../util/get-or-set';
-import { mapOwn } from '../util/map-own';
 import { getRuntime } from '../config/config';
-var ctxId = 'nr@context';
+import { EventContext } from './event-context';
+import { bundleId } from '../ids/bundle-id';
 
+// create a unique id to store event context data for the current agent bundle
+const contextId = "nr@context:".concat(bundleId);
 // create global emitter instance that can be shared among bundles
-let nr = gosNREUM();
-var globalInstance;
-if (nr.ee) {
-  globalInstance = nr.ee;
-} else {
-  globalInstance = ee(undefined, 'globalEE');
+const globalInstance = ee(undefined, 'globalEE');
+
+// Only override the exposed event emitter if one has not already been exposed
+const nr = gosNREUM();
+if (!nr.ee) {
   nr.ee = globalInstance;
 }
-export { globalInstance as ee };
-function EventContext() {}
+export { globalInstance as ee, contextId };
 function ee(old, debugId) {
   var handlers = {};
   var bufferGroupMap = {};
@@ -56,9 +56,9 @@ function ee(old, debugId) {
     if (contextOrStore && contextOrStore instanceof EventContext) {
       return contextOrStore;
     } else if (contextOrStore) {
-      return getOrSet(contextOrStore, ctxId, getNewContext);
+      return getOrSet(contextOrStore, contextId, () => new EventContext(contextId));
     } else {
-      return getNewContext();
+      return new EventContext(contextId);
     }
   }
   function emit(type, args, contextOrStore, force, bubble) {
@@ -105,12 +105,13 @@ function ee(old, debugId) {
     return emitters[name] = emitters[name] || ee(emitter, name);
   }
   function bufferEventsByGroup(types, group) {
-    var eventBuffer = getBuffer();
+    const eventBuffer = getBuffer();
+    group = group || 'feature';
 
     // do not buffer events if agent has been aborted
     if (emitter.aborted) return;
-    mapOwn(types, function (i, type) {
-      group = group || 'feature';
+    Object.entries(types || {}).forEach(_ref => {
+      let [_, type] = _ref;
       bufferGroupMap[type] = group;
       if (!(group in eventBuffer)) {
         eventBuffer[group] = [];
@@ -128,14 +129,6 @@ function ee(old, debugId) {
     return emitter.backlog;
   }
 }
-
-// get context object from store object, or create if does not exist
-export function getOrSetContext(obj) {
-  return getOrSet(obj, ctxId, getNewContext);
-}
-function getNewContext() {
-  return new EventContext();
-}
 function abort() {
   globalInstance.aborted = true;
   globalInstance.backlog = {};

package/dist/esm/common/event-emitter/event-context.js

@@ -0,0 +1,5 @@
+export class EventContext {
+  constructor(contextId) {
+    this.contextId = contextId;
+  }
+}

package/dist/esm/common/harvest/harvest.js

@@ -48,7 +48,8 @@ export class Harvest extends SharedContext {
       isFinalHarvest: spec.opts?.unload
     });
     const options = {
-      retry: !spec.opts?.unload && submitMethod === submitData.xhr
+      retry: !spec.opts?.unload && submitMethod === submitData.xhr,
+      isFinalHarvest: spec.opts?.unload === true
     };
     const payload = this.createPayload(spec.endpoint, options);
     const caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this);
@@ -250,9 +251,8 @@ export class Harvest extends SharedContext {
   cleanPayload() {
     let payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     const clean = input => {
-      if (typeof Uint8Array !== 'undefined' && input instanceof Uint8Array || typeof input === 'string') {
-        return input.length > 0 ? input : null;
-      }
+      if (typeof Uint8Array !== 'undefined' && input instanceof Uint8Array || Array.isArray(input)) return input;
+      if (typeof input === 'string') return input.length > 0 ? input : null;
       return Object.entries(input || {}).reduce((accumulator, _ref2) => {
         let [key, value] = _ref2;
         if (typeof value === 'number' || typeof value === 'string' && value.length > 0 || typeof value === 'object' && Object.keys(value || {}).length > 0) {

package/dist/esm/common/ids/bundle-id.js

@@ -0,0 +1,13 @@
+/**
+ * @file Contains a unique identifier for the running agent bundle
+ * when loaded.
+ * @copyright 2023 New Relic Corporation. All rights reserved.
+ * @license Apache-2.0
+ */
+
+import { generateUuid } from './unique-id';
+
+/**
+ * Provides a unique id for the current agent bundle
+ */
+export const bundleId = generateUuid();

package/dist/esm/common/wrap/wrap-events.js

@@ -7,14 +7,15 @@
  * This module is used directly by: session_trace.
  * It is also called by -> wrapXhr <-, so see "wrap-xhr.js" for features that use this indirectly.
  */
-import { ee as baseEE } from '../event-emitter/contextual-ee';
+import { ee as baseEE, contextId } from '../event-emitter/contextual-ee';
 import { createWrapperWithEmitter as wfn } from './wrap-function';
 import { getOrSet } from '../util/get-or-set';
 import { globalScope, isBrowserScope } from '../constants/runtime';
 const wrapped = {};
-const XHR = XMLHttpRequest;
+const XHR = globalScope.XMLHttpRequest;
 const ADD_EVENT_LISTENER = 'addEventListener';
 const REMOVE_EVENT_LISTENER = 'removeEventListener';
+const flag = "nr@wrapped:".concat(contextId);
 
 /**
  * Wraps `addEventListener` and `removeEventListener` on: global scope; the prototype of `XMLHttpRequest`, and
@@ -43,7 +44,7 @@ export function wrapEvents(sharedEE) {
     if (originalListener === null || typeof originalListener !== 'function' && typeof originalListener !== 'object') {
       return;
     }
-    var wrapped = getOrSet(originalListener, 'nr@wrapped', function () {
+    var wrapped = getOrSet(originalListener, flag, function () {
       var listener = {
         object: wrapHandleEvent,
         function: originalListener

package/dist/esm/common/wrap/wrap-fetch.js

@@ -6,16 +6,14 @@
  * @file Wraps `fetch` and related methods for instrumentation.
  * This module is used by: ajax, spa.
  */
-import { ee as baseEE } from '../event-emitter/contextual-ee';
+import { ee as baseEE, contextId } from '../event-emitter/contextual-ee';
 import { globalScope } from '../constants/runtime';
-import { flag } from './wrap-function';
 var prefix = 'fetch-';
 var bodyPrefix = prefix + 'body-';
 var bodyMethods = ['arrayBuffer', 'blob', 'json', 'text', 'formData'];
 var Req = globalScope.Request;
 var Res = globalScope.Response;
 var proto = 'prototype';
-var ctxId = 'nr@context';
 const wrapped = {};
 
 /**
@@ -72,7 +70,7 @@ export function wrapFetch(sharedEE) {
         // we are wrapping args in an array so we can preserve the reference
         ee.emit(prefix + 'before-start', [args], ctx);
         var dtPayload;
-        if (ctx[ctxId] && ctx[ctxId].dt) dtPayload = ctx[ctxId].dt;
+        if (ctx[contextId] && ctx[contextId].dt) dtPayload = ctx[contextId].dt;
         var origPromiseFromFetch = fn.apply(this, args);
         ee.emit(prefix + 'start', [args, dtPayload], origPromiseFromFetch);
 

package/dist/esm/common/wrap/wrap-function.js

@@ -7,7 +7,8 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee';
-export const flag = 'nr@original';
+import { bundleId } from '../ids/bundle-id';
+export const flag = "nr@original:".concat(bundleId);
 
 /**
  * A convenience alias of `hasOwnProperty`.
@@ -100,25 +101,23 @@ export function createWrapperWithEmitter(emitter, always) {
 
   /**
    * Creates wrapper functions around each of an array of methods on a specified object.
-   * @param {Object} obj - The object to which the specified methods belong.
-   * @param {string[]} methods - An array of method names to be wrapped.
-   * @param {string} [prefix=''] - A prefix to add to the names of emitted events. If `-` is the first character, also
-   *     adds the method name before the prefix.
-   * @param {function|object} [getContext] - The function or object that will serve as the 'this' context for handlers
-   *     of events emitted by this wrapper.
-   * @param {boolean} [bubble=false] - If `true`, emitted events should also bubble up to the old emitter upon which
-   *     the `emitter` in the current scope was based (if it defines one).
+   * @param {Object} obj The object to which the specified methods belong.
+   * @param {string[]} methods An array of method names to be wrapped.
+   * @param {string} [prefix=''] A prefix to add to the names of emitted events. If `-` is the first character, also
+   * adds the method name before the prefix.
+   * @param {function|object} [getContext] The function or object that will serve as the 'this' context for handlers
+   * of events emitted by this wrapper.
+   * @param {boolean} [bubble=false] If `true`, emitted events should also bubble up to the old emitter upon which
+   * the `emitter` in the current scope was based (if it defines one).
    */
   function inPlace(obj, methods, prefix, getContext, bubble) {
     if (!prefix) prefix = '';
+
     // If prefix starts with '-' set this boolean to add the method name to the prefix before passing each one to wrap.
-    var prependMethodPrefix = prefix.charAt(0) === '-';
-    var fn;
-    var method;
-    var i;
-    for (i = 0; i < methods.length; i++) {
-      method = methods[i];
-      fn = obj[method];
+    const prependMethodPrefix = prefix.charAt(0) === '-';
+    for (let i = 0; i < methods.length; i++) {
+      const method = methods[i];
+      const fn = obj[method];
 
       // Unless fn is both wrappable and unwrapped, bail so we don't add extra properties with undefined values.
       if (notWrappable(fn)) continue;
@@ -212,32 +211,4 @@ function copy(from, to, emitter) {
  */
 function notWrappable(fn) {
   return !(fn && fn instanceof Function && fn.apply && !fn[flag]);
-}
-
-/**
- * Creates a wrapped version of a function using a specified wrapper function. The new wrapped function references the
- * original function. Also copies the properties of the original function to the wrapped function.
- * @param {function} fn - A function to be wrapped.
- * @param {function} wrapper - A higher order function that returns a new function, which executes the function passed
- *     to the higher order function as an argument.
- * @returns {function} A wrapped function with an internal reference to the original function.
- */
-export function wrapFunction(fn, wrapper) {
-  var wrapped = wrapper(fn);
-  wrapped[flag] = fn;
-  copy(fn, wrapped, ee);
-  return wrapped;
-}
-
-/**
- * Replaces a function with a wrapped version of itself. To preserve object references, rather than taking the function
- * itself as an argument, takes the object on which the particular named function is a property.
- * @param {Object} obj - The object on which the named function is a property.
- * @param {string} fnName - The name of the function to be wrapped.
- * @param {function} wrapper - A higher order function that returns a new function, which executes the function passed
- *     to the higher order function as an argument.
- */
-export function wrapInPlace(obj, fnName, wrapper) {
-  var fn = obj[fnName];
-  obj[fnName] = wrapFunction(fn, wrapper);
 }

package/dist/esm/common/wrap/wrap-mutation.js

@@ -9,8 +9,7 @@
 
 import { ee as baseEE } from '../event-emitter/contextual-ee';
 import { createWrapperWithEmitter as wfn } from './wrap-function';
-import { originals } from '../config/config';
-import { isBrowserScope } from '../constants/runtime';
+import { globalScope, isBrowserScope } from '../constants/runtime';
 const wrapped = {};
 
 /**
@@ -29,7 +28,7 @@ export function wrapMutation(sharedEE) {
   wrapped[ee.debugId] = true; // otherwise, first feature to wrap mutations
 
   var wrapFn = wfn(ee);
-  var OriginalObserver = originals.MO;
+  var OriginalObserver = globalScope.MutationObserver;
   if (OriginalObserver) {
     window.MutationObserver = function WrappedMutationObserver(cb) {
       if (this instanceof OriginalObserver) {

package/dist/esm/common/wrap/wrap-promise.js

@@ -8,8 +8,7 @@
  */
 
 import { createWrapperWithEmitter as wrapFn, flag } from './wrap-function';
-import { ee as baseEE, getOrSetContext } from '../event-emitter/contextual-ee';
-import { originals } from '../config/config';
+import { ee as baseEE } from '../event-emitter/contextual-ee';
 import { globalScope } from '../constants/runtime';
 const wrapped = {};
 
@@ -28,9 +27,9 @@ export function wrapPromise(sharedEE) {
   if (wrapped[promiseEE.debugId]) return promiseEE;
   wrapped[promiseEE.debugId] = true; // otherwise, first feature to wrap promise
 
-  var getContext = getOrSetContext;
+  var getContext = promiseEE.context;
   var promiseWrapper = wrapFn(promiseEE);
-  var prevPromiseObj = originals.PR;
+  var prevPromiseObj = globalScope.Promise;
   if (prevPromiseObj) {
     // ensure there's a Promise API (native or otherwise) to even wrap
     wrap();

package/dist/esm/common/wrap/wrap-xhr.js

@@ -11,7 +11,6 @@ import { wrapEvents } from './wrap-events';
 import { ee as contextualEE } from '../event-emitter/contextual-ee';
 import { eventListenerOpts } from '../event-listener/event-listener-opts';
 import { createWrapperWithEmitter as wfn } from './wrap-function';
-import { originals } from '../config/config';
 import { globalScope } from '../constants/runtime';
 import { warn } from '../util/console';
 const wrapped = {};
@@ -35,32 +34,28 @@ export function wrapXhr(sharedEE) {
 
   wrapEvents(baseEE); // wrap-events patches XMLHttpRequest.prototype.addEventListener for us
   var wrapFn = wfn(ee);
-  var OrigXHR = originals.XHR;
-  var MutationObserver = originals.MO;
-  var Promise = originals.PR;
-  var setImmediate = originals.SI;
+  var OrigXHR = globalScope.XMLHttpRequest;
+  var MutationObserver = globalScope.MutationObserver;
+  var Promise = globalScope.Promise;
+  var setImmediate = globalScope.setInterval;
   var READY_STATE_CHANGE = 'readystatechange';
   var handlers = ['onload', 'onerror', 'onabort', 'onloadstart', 'onloadend', 'onprogress', 'ontimeout'];
   var pendingXhrs = [];
-  var activeListeners = globalScope.XMLHttpRequest.listeners;
   var XHR = globalScope.XMLHttpRequest = newXHR;
   function newXHR(opts) {
-    var xhr = new OrigXHR(opts);
-    this.listeners = activeListeners ? [...activeListeners, intercept] : [intercept];
-    function intercept() {
+    const xhr = new OrigXHR(opts);
+    const context = ee.context(xhr);
+    try {
+      ee.emit('new-xhr', [xhr], context);
+      xhr.addEventListener(READY_STATE_CHANGE, wrapXHR(context), eventListenerOpts(false));
+    } catch (e) {
+      warn('An error occurred while intercepting XHR', e);
       try {
-        ee.emit('new-xhr', [xhr], xhr);
-        xhr.addEventListener(READY_STATE_CHANGE, wrapXHR, eventListenerOpts(false));
-      } catch (e) {
-        warn('An error occured while intercepting XHR', e);
-        try {
-          ee.emit('internal-error', [e]);
-        } catch (err) {
-          // do nothing
-        }
+        ee.emit('internal-error', [e]);
+      } catch (err) {
+        // do nothing
       }
     }
-    this.listeners.forEach(listener => listener());
     return xhr;
   }
   copy(OrigXHR, XHR);
@@ -74,14 +69,15 @@ export function wrapXhr(sharedEE) {
   function wrapOnreadystatechange(args, xhr) {
     wrapFn.inPlace(xhr, ['onreadystatechange'], 'fn-', getObject);
   }
-  function wrapXHR() {
-    var xhr = this;
-    var ctx = ee.context(xhr);
-    if (xhr.readyState > 3 && !ctx.resolved) {
-      ctx.resolved = true;
-      ee.emit('xhr-resolved', [], xhr);
-    }
-    wrapFn.inPlace(xhr, handlers, 'fn-', getObject);
+  function wrapXHR(ctx) {
+    return function () {
+      var xhr = this;
+      if (xhr.readyState > 3 && !ctx.resolved) {
+        ctx.resolved = true;
+        ee.emit('xhr-resolved', [], xhr);
+      }
+      wrapFn.inPlace(xhr, handlers, 'fn-', getObject);
+    };
   }
 
   // Wrapping the onreadystatechange property of XHRs takes some special tricks.

package/dist/esm/features/ajax/instrument/distributed-tracing.js

@@ -10,10 +10,6 @@ import { stringify } from '../../../common/util/stringify';
 export class DT {
   constructor(agentIdentifier) {
     this.agentIdentifier = agentIdentifier;
-    // Binds this class instance context to the following fn used in an external module (exported);
-    //  Alternatively, can make them class field arrow functions, but requires experimental features/plugin for eslint.
-    this.generateTracePayload = this.generateTracePayload.bind(this);
-    this.shouldGenerateTrace = this.shouldGenerateTrace.bind(this);
   }
   generateTracePayload(parsedOrigin) {
     if (!this.shouldGenerateTrace(parsedOrigin)) {

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

@@ -5,7 +5,7 @@
 import { originals, getLoaderConfig, getRuntime } from '../../../common/config/config';
 import { handle } from '../../../common/event-emitter/handle';
 import { id } from '../../../common/ids/id';
-import { ffVersion, globalScope } from '../../../common/constants/runtime';
+import { ffVersion, globalScope, isBrowserScope } from '../../../common/constants/runtime';
 import { dataSize } from '../../../common/util/data-size';
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts';
 import { now } from '../../../common/timing/now';
@@ -19,7 +19,7 @@ import { FEATURE_NAMES } from '../../../loaders/features/features';
 var handlers = ['load', 'error', 'abort', 'timeout'];
 var handlersLen = handlers.length;
 var origRequest = originals.REQ;
-var origXHR = globalScope.XMLHttpRequest;
+var origXHR = originals.XHR;
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
@@ -185,15 +185,25 @@ function subscribeToEvents(agentIdentifier, ee, handler, dt) {
   function onFetchBeforeStart(args) {
     var opts = args[1] || {};
     var url;
-    // argument is USVString
     if (typeof args[0] === 'string') {
+      // argument is USVString
       url = args[0];
-      // argument is Request object
+      if (url.length === 0 && isBrowserScope) {
+        url = '' + globalScope.location.href;
+      }
     } else if (args[0] && args[0].url) {
+      // argument is Request object
       url = args[0].url;
-      // argument is URL object
     } else if (globalScope?.URL && args[0] && args[0] instanceof URL) {
+      // argument is URL object
       url = args[0].href;
+    } else if (typeof args[0].toString === 'function') {
+      url = args[0].toString();
+    }
+    if (typeof url !== 'string' || url.length === 0) {
+      // Short-circuit DT since we could not determine the URL of the fetch call
+      // this is very unlikely to happen
+      return;
     }
     if (url) {
       this.parsedOrigin = parseUrl(url);
@@ -203,7 +213,11 @@ function subscribeToEvents(agentIdentifier, ee, handler, dt) {
     if (!payload || !payload.newrelicHeader && !payload.traceContextParentHeader) {
       return;
     }
-    if (typeof args[0] === 'string' || globalScope?.URL && args[0] && args[0] instanceof URL) {
+    if (args[0] && args[0].headers) {
+      if (addHeaders(args[0].headers, payload)) {
+        this.dt = payload;
+      }
+    } else {
       var clone = {};
       for (var key in opts) {
         clone[key] = opts[key];
@@ -217,10 +231,6 @@ function subscribeToEvents(agentIdentifier, ee, handler, dt) {
       } else {
         args.push(clone);
       }
-    } else if (args[0] && args[0].headers) {
-      if (addHeaders(args[0].headers, payload)) {
-        this.dt = payload;
-      }
     }
     function addHeaders(headersObj, payload) {
       var added = false;

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

@@ -148,6 +148,14 @@ export class Aggregate extends AggregateBase {
       // Capture metrics for size of custom attributes
       const jsAttributes = stringify(info.jsAttributes);
       this.storeSupportabilityMetrics('PageSession/Feature/CustomData/Bytes', jsAttributes === '{}' ? 0 : jsAttributes.length);
+
+      // Capture metrics for performance markers and measures
+      if (typeof performance !== 'undefined') {
+        const markers = performance.getEntriesByType('mark');
+        const measures = performance.getEntriesByType('measure');
+        this.storeSupportabilityMetrics('Generic/Performance/Mark/Seen', markers.length);
+        this.storeSupportabilityMetrics('Generic/Performance/Measure/Seen', measures.length);
+      }
     } catch (e) {
       // do nothing
     }

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

@@ -174,11 +174,13 @@ export class Aggregate extends AggregateBase {
       this.scheduler.startTimer(this.harvestTimeSeconds);
     }
     try {
+      // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
       recorder = (await import( /* webpackChunkName: "recorder" */'rrweb')).record;
     } catch (err) {
       return this.abort();
     }
     try {
+      // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
       const {
         gzipSync,
         strToU8

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

@@ -57,9 +57,13 @@ export class Aggregate extends AggregateBase {
     this.sentTrace = null;
     this.harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10;
     this.maxNodesPerHarvest = getConfigurationValue(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000;
+    /**
+     * Standalone (mode) refers to the legacy version of ST before the idea of 'session' or the Replay feature existed.
+     * It has some different behavior vs when used in tandem with replay. */
     this.isStandalone = false;
     const operationalGate = new HandlerCache(); // acts as a controller-intermediary that can enable or disable this feature's collection dynamically
     const sessionEntity = this.agentRuntime.session;
+    this.operationalGate = operationalGate;
 
     /* --- The following section deals with user sessions concept & contains non-trivial control flow. --- */
     const controlTraceOp = traceMode => {
@@ -243,17 +247,16 @@ export class Aggregate extends AggregateBase {
     }
   }
   #prepareHarvest(options) {
-    /* Standalone refers to the legacy version of ST before the idea of 'session' or the Replay feature existed.
-      It has a different behavior on returning a payload for harvest than when used in tandem with either of those concepts. */
     if (this.isStandalone) {
-      if (now() > MAX_TRACE_DURATION) {
-        // been collecting for over the longest duration we should run for, empty trace object so ST has nothing to send
-        this.#scheduler.stopTimer();
-        this.trace = {};
+      if (this.ptid && now() >= MAX_TRACE_DURATION) {
+        // Perform a final harvest once we hit or exceed the max session trace time
+        options.isFinalHarvest = true;
+        this.operationalGate.permanentlyDecide(false);
+        this.#scheduler.stopTimer(true);
+      } else if (this.ptid && this.nodeCount <= REQ_THRESHOLD_TO_SEND && !options.isFinalHarvest) {
+        // Only harvest when more than some threshold of nodes are pending, after the very first harvest, with the exception of the last outgoing harvest.
         return;
       }
-      // Only harvest when more than some threshold of nodes are pending, after the very first harvest.
-      if (this.ptid && this.nodeCount <= REQ_THRESHOLD_TO_SEND) return;
     } else {
       //   -- *cli May '26 - Update: Not rate limiting backgrounded pages either for now.
       //   if (this.ptid && document.visibilityState === 'hidden' && this.nodeCount <= REQ_THRESHOLD_TO_SEND) return
@@ -443,6 +446,9 @@ export class Aggregate extends AggregateBase {
       const openedSpace = this.trimSTNs(ERROR_MODE_SECONDS_WINDOW); // but maybe we could make some space by discarding irrelevant nodes if we're in sessioned Error mode
       if (openedSpace == 0) return;
     }
+    if (this.isStandalone && now() >= MAX_TRACE_DURATION) {
+      return;
+    }
     if (this.trace[stn.n]) this.trace[stn.n].push(stn);else this.trace[stn.n] = [stn];
     this.nodeCount++;
   }

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

@@ -398,7 +398,7 @@ export class Aggregate extends AggregateBase {
     register(FETCH_DONE, function (err, res) {
       var node = this[SPA_NODE];
       if (node) {
-        if (err) {
+        if (err || !shouldCollectEvent(this.params)) {
           node.cancel();
           return;
         }