@newrelic/browser-agent 1.264.0 → 1.265.0

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

@@ -1,6 +1,8 @@
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
-import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
+import { getConfigurationValue } from '../../../common/config/init';
+import { getRuntime } from '../../../common/config/runtime';
 import { FEATURE_NAME } from '../constants';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { TraceStorage } from './trace/storage';
@@ -8,11 +10,12 @@ import { obj as encodeObj } from '../../../common/url/encode';
 import { deregisterDrain } from '../../../common/drain/drain';
 import { globalScope } from '../../../common/constants/runtime';
 import { MODE, SESSION_EVENTS } from '../../../common/session/constants';
+import { applyFnToProps } from '../../../common/util/traverse';
 const ERROR_MODE_SECONDS_WINDOW = 30 * 1000; // sliding window of nodes to track when simply monitoring (but not harvesting) in error mode
 /** Reserved room for query param attrs */
 const QUERY_PARAM_PADDING = 5000;
 export class Aggregate extends AggregateBase {
-  static featureName = (() => FEATURE_NAME)();
+  static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
     this.agentRuntime = getRuntime(agentIdentifier);
@@ -30,15 +33,11 @@ export class Aggregate extends AggregateBase {
     /** TraceStorage is the mechanism that holds, normalizes and aggregates ST nodes.  It will be accessed and purged when harvests occur */
     this.traceStorage = new TraceStorage(this);
     /** This agg needs information about sampling (sts) and entitlements (st) to make the appropriate decisions on running */
-    this.waitForFlags(['sts', 'st']).then(_ref => {
-      let [stMode, stEntitled] = _ref;
-      return this.initialize(stMode, stEntitled);
-    });
+    this.waitForFlags(['sts', 'st']).then(([stMode, stEntitled]) => this.initialize(stMode, stEntitled));
   }
 
   /** Sets up event listeners, and initializes this module to run in the correct "mode".  Can be triggered from a few places, but makes an effort to only set up listeners once */
   initialize(stMode, stEntitled, ignoreSession) {
-    var _this = this;
     this.entitled ??= stEntitled;
     if (this.blocked || !this.entitled) return deregisterDrain(this.agentIdentifier, this.featureName);
     if (!this.initialized) {
@@ -78,31 +77,17 @@ export class Aggregate extends AggregateBase {
     }, this);
 
     /** The handlers set up by the Inst file */
-    registerHandler('bst', function () {
-      return _this.traceStorage.storeEvent(...arguments);
-    }, this.featureName, this.ee);
-    registerHandler('bstResource', function () {
-      return _this.traceStorage.storeResources(...arguments);
-    }, this.featureName, this.ee);
-    registerHandler('bstHist', function () {
-      return _this.traceStorage.storeHist(...arguments);
-    }, this.featureName, this.ee);
-    registerHandler('bstXhrAgg', function () {
-      return _this.traceStorage.storeXhrAgg(...arguments);
-    }, this.featureName, this.ee);
-    registerHandler('bstApi', function () {
-      return _this.traceStorage.storeSTN(...arguments);
-    }, this.featureName, this.ee);
-    registerHandler('trace-jserror', function () {
-      return _this.traceStorage.storeErrorAgg(...arguments);
-    }, this.featureName, this.ee);
-    registerHandler('pvtAdded', function () {
-      return _this.traceStorage.processPVT(...arguments);
-    }, this.featureName, this.ee);
+    registerHandler('bst', (...args) => this.traceStorage.storeEvent(...args), this.featureName, this.ee);
+    registerHandler('bstResource', (...args) => this.traceStorage.storeResources(...args), this.featureName, this.ee);
+    registerHandler('bstHist', (...args) => this.traceStorage.storeHist(...args), this.featureName, this.ee);
+    registerHandler('bstXhrAgg', (...args) => this.traceStorage.storeXhrAgg(...args), this.featureName, this.ee);
+    registerHandler('bstApi', (...args) => this.traceStorage.storeSTN(...args), this.featureName, this.ee);
+    registerHandler('trace-jserror', (...args) => this.traceStorage.storeErrorAgg(...args), this.featureName, this.ee);
+    registerHandler('pvtAdded', (...args) => this.traceStorage.processPVT(...args), this.featureName, this.ee);
     if (typeof PerformanceNavigationTiming !== 'undefined') {
       this.traceStorage.storeTiming(globalScope.performance?.getEntriesByType?.('navigation')[0]);
     } else {
-      this.traceStorage.storeTiming(globalScope.performance?.timing);
+      this.traceStorage.storeTiming(globalScope.performance?.timing, true);
     }
 
     /** Only start actually harvesting if running in full mode at init time */
@@ -126,8 +111,7 @@ export class Aggregate extends AggregateBase {
   }
 
   /** Called by the harvest scheduler at harvest time to retrieve the payload.  This will only actually return a payload if running in full mode */
-  prepareHarvest() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  prepareHarvest(options = {}) {
     this.traceStorage.prevStoredEvents.clear(); // release references to past events for GC
     if (!this.timeKeeper?.ready) return; // this should likely never happen, but just to be safe, we should never harvest if we cant correct time
     if (this.blocked || this.mode !== MODE.FULL || this.traceStorage.nodeCount === 0) return;
@@ -166,7 +150,7 @@ export class Aggregate extends AggregateBase {
         type: 'BrowserSessionChunk',
         app_id: this.agentInfo.applicationID,
         protocol_version: '0',
-        timestamp: this.timeKeeper.convertRelativeTimestamp(earliestTimeStamp),
+        timestamp: Math.floor(this.timeKeeper.correctAbsoluteTimestamp(this.timeKeeper.convertRelativeTimestamp(earliestTimeStamp))),
         attributes: encodeObj({
           ...(agentMetadata.entityGuid && {
             entityGuid: agentMetadata.entityGuid
@@ -175,8 +159,8 @@ export class Aggregate extends AggregateBase {
           // this section of attributes must be controllable and stay below the query param padding limit -- see QUERY_PARAM_PADDING
           // if not, data could be lost to truncation at time of sending, potentially breaking parsing / API behavior in NR1
           // trace payload metadata
-          'trace.firstTimestamp': this.timeKeeper.convertRelativeTimestamp(earliestTimeStamp),
-          'trace.lastTimestamp': this.timeKeeper.convertRelativeTimestamp(latestTimeStamp),
+          'trace.firstTimestamp': Math.floor(this.timeKeeper.correctAbsoluteTimestamp(this.timeKeeper.convertRelativeTimestamp(earliestTimeStamp))),
+          'trace.lastTimestamp': Math.floor(this.timeKeeper.correctAbsoluteTimestamp(this.timeKeeper.convertRelativeTimestamp(latestTimeStamp))),
           'trace.nodes': stns.length,
           'trace.originTimestamp': this.timeKeeper.correctedOriginTime,
           // other payload metadata
@@ -191,12 +175,12 @@ export class Aggregate extends AggregateBase {
           session: "".concat(this.sessionId),
           // customer-defined data should go last so that if it exceeds the query param padding limit it will be truncated instead of important attrs
           ...(endUserId && {
-            'enduser.id': endUserId
+            'enduser.id': this.obfuscator.obfuscateString(endUserId)
           })
           // The Query Param is being arbitrarily limited in length here.  It is also applied when estimating the size of the payload in getPayloadSize()
         }, QUERY_PARAM_PADDING).substring(1) // remove the leading '&'
       },
-      body: stns
+      body: applyFnToProps(stns, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
     };
   }
 
@@ -206,8 +190,7 @@ export class Aggregate extends AggregateBase {
   onHarvestFinished(result) {
     if (result.sent && result.retry && this.sentTrace) {
       // merge previous trace back into buffer to retry for next harvest
-      Object.entries(this.sentTrace).forEach(_ref2 => {
-        let [name, listOfSTNodes] = _ref2;
+      Object.entries(this.sentTrace).forEach(([name, listOfSTNodes]) => {
         this.traceStorage.restoreNode(name, listOfSTNodes);
       });
       this.sentTrace = null;

package/dist/esm/features/session_trace/aggregate/trace/storage.js

@@ -33,10 +33,10 @@ const toAggregate = {
 export class TraceStorage {
   nodeCount = 0;
   trace = {};
-  earliestTimeStamp = (() => Infinity)();
+  earliestTimeStamp = Infinity;
   latestTimeStamp = 0;
   tempStorage = [];
-  prevStoredEvents = (() => new Set())();
+  prevStoredEvents = new Set();
   constructor(parent) {
     this.parent = parent;
   }
@@ -91,8 +91,7 @@ export class TraceStorage {
       // if PO isn't supported, this checks resourcetiming buffer every harvest.
       this.storeResources(globalScope.performance?.getEntriesByType?.('resource'));
     }
-    const stns = Object.entries(this.trace).flatMap(_ref => {
-      let [name, listOfSTNodes] = _ref;
+    const stns = Object.entries(this.trace).flatMap(([name, listOfSTNodes]) => {
       // basically take the "this.trace" map-obj and concat all the list-type values
       if (!(name in toAggregate)) return listOfSTNodes;
       // Special processing for event nodes dealing with user inputs:
@@ -150,7 +149,7 @@ export class TraceStorage {
       return name === 'fi' && !!attrs && typeof attrs.fid === 'number';
     }
   }
-  storeTiming(timingEntry) {
+  storeTiming(timingEntry, isAbsoluteTimestamp = false) {
     if (!timingEntry) return;
 
     // loop iterates through prototype also (for FF)
@@ -165,6 +164,9 @@ export class TraceStorage {
       // that are in the future (Microsoft Edge seems to sometimes produce these)
       if (!(typeof val === 'number' && val >= 0)) continue;
       val = Math.round(val);
+      if (this.parent.timeKeeper && this.parent.timeKeeper.ready && isAbsoluteTimestamp) {
+        val = this.parent.timeKeeper.convertAbsoluteTimestamp(Math.floor(this.parent.timeKeeper.correctAbsoluteTimestamp(val)));
+      }
       this.storeSTN(new TraceNode(key, val, val, 'document', 'timing'));
     }
   }

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

@@ -3,7 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { handle } from '../../../common/event-emitter/handle';
-import { wrapHistory, wrapEvents } from '../../../common/wrap';
+import { wrapHistory } from '../../../common/wrap/wrap-history';
+import { wrapEvents } from '../../../common/wrap/wrap-events';
 import { InstrumentBase } from '../../utils/instrument-base';
 import * as CONSTANTS from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
@@ -21,9 +22,8 @@ const {
   PUSH_STATE
 } = CONSTANTS;
 export class Instrument extends InstrumentBase {
-  static featureName = (() => FEATURE_NAME)();
-  constructor(agentIdentifier, aggregator) {
-    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
     const canTrackSession = canEnableSessionTracking(this.agentIdentifier);
     if (!canTrackSession) {
@@ -67,4 +67,5 @@ export class Instrument extends InstrumentBase {
       resourceObserver: observer
     });
   }
-}
+}
+export const SessionTrace = Instrument;

package/dist/esm/features/soft_navigations/aggregate/ajax-node.js

@@ -16,7 +16,7 @@ export class AjaxNode extends BelNode {
     this.traceId = ajaxEvent.traceId;
     this.spanTimestamp = ajaxEvent.spanTimestamp;
     this.gql = ajaxEvent.gql;
-    this.start = ajaxEvent.startTime;
+    this.start = ajaxEvent.startTime; // 5000 --- 5500 --> 10500
     this.end = ajaxEvent.endTime;
   }
   serialize(parentStartTimestamp) {

package/dist/esm/features/soft_navigations/aggregate/bel-node.js

@@ -7,7 +7,7 @@ export class BelNode {
   end;
   callbackEnd = 0;
   callbackDuration = 0;
-  nodeId = (() => ++nodesSeen)();
+  nodeId = ++nodesSeen;
   constructor(agentIdentifier) {
     if (!agentIdentifier) throw new Error('Interaction is missing core attributes');
     this.agentIdentifier = agentIdentifier;

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

@@ -1,4 +1,4 @@
-import { getConfigurationValue } from '../../../common/config/config';
+import { getConfigurationValue } from '../../../common/config/init';
 import { deregisterDrain } from '../../../common/drain/drain';
 import { handle } from '../../../common/event-emitter/handle';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
@@ -8,30 +8,28 @@ import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { AggregateBase } from '../../utils/aggregate-base';
+import { EventBuffer } from '../../utils/event-buffer';
 import { API_TRIGGER_NAME, FEATURE_NAME, INTERACTION_STATUS } from '../constants';
 import { AjaxNode } from './ajax-node';
 import { InitialPageLoadInteraction } from './initial-page-load-interaction';
 import { Interaction } from './interaction';
 export class Aggregate extends AggregateBase {
-  static featureName = (() => FEATURE_NAME)();
-  constructor(agentIdentifier, aggregator, _ref) {
-    let {
-      domObserver
-    } = _ref;
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, {
+    domObserver
+  }) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
     const harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'soft_navigations.harvestTimeSeconds') || 10;
-    this.interactionsToHarvest = [];
-    this.interactionsAwaitingRetry = [];
+    this.interactionsToHarvest = new EventBuffer();
     this.domObserver = domObserver;
     this.initialPageLoadInteraction = new InitialPageLoadInteraction(agentIdentifier);
-    timeToFirstByte.subscribe(_ref2 => {
-      let {
-        attrs
-      } = _ref2;
+    timeToFirstByte.subscribe(({
+      attrs
+    }) => {
       const loadEventTime = attrs.navigationEntry.loadEventEnd;
       this.initialPageLoadInteraction.forceSave = true;
       this.initialPageLoadInteraction.done(loadEventTime);
-      this.interactionsToHarvest.push(this.initialPageLoadInteraction);
+      this.interactionsToHarvest.add(this.initialPageLoadInteraction);
       this.initialPageLoadInteraction = null;
       // Report metric on the initial page load time
       handle(SUPPORTABILITY_METRIC_CHANNEL, ['SoftNav/Interaction/InitialPageLoad/Duration/Ms', Math.round(loadEventTime)], undefined, FEATURE_NAMES.metrics, this.ee);
@@ -40,8 +38,7 @@ export class Aggregate extends AggregateBase {
     this.interactionInProgress = null; // aside from the "page load" interaction, there can only ever be 1 ongoing at a time
 
     this.blocked = false;
-    this.waitForFlags(['spa']).then(_ref3 => {
-      let [spaOn] = _ref3;
+    this.waitForFlags(['spa']).then(([spaOn]) => {
       if (spaOn) {
         this.drain();
         const scheduler = new HarvestScheduler('events', {
@@ -72,18 +69,17 @@ export class Aggregate extends AggregateBase {
     registerHandler('jserror', this.#handleJserror.bind(this), this.featureName, this.ee);
   }
   onHarvestStarted(options) {
-    if (this.interactionsToHarvest.length === 0 || this.blocked) return;
+    if (!this.interactionsToHarvest.hasData || this.blocked) return;
     // 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
     const serializedIxnList = [];
-    for (const interaction of this.interactionsToHarvest) {
+    for (const interaction of this.interactionsToHarvest.buffer) {
       serializedIxnList.push(interaction.serialize(firstIxnStartTime));
       if (!firstIxnStartTime) firstIxnStartTime = Math.floor(interaction.start);
     }
     const payload = "bel.7;".concat(serializedIxnList.join(';'));
-    if (options.retry) this.interactionsAwaitingRetry = this.interactionsToHarvest;
-    this.interactionsToHarvest = [];
+    if (options.retry) this.interactionsToHarvest.hold();else this.interactionsToHarvest.clear();
     return {
       body: {
         e: payload
@@ -91,10 +87,7 @@ export class Aggregate extends AggregateBase {
     };
   }
   onHarvestFinished(result) {
-    if (result.sent && result.retry && this.interactionsAwaitingRetry.length > 0) {
-      this.interactionsToHarvest = [...this.interactionsAwaitingRetry, ...this.interactionsToHarvest];
-    }
-    this.interactionsAwaitingRetry = [];
+    if (result.sent && result.retry && this.interactionsToHarvest.held.hasData) this.interactionsToHarvest.unhold();else this.interactionsToHarvest.held.clear();
   }
   startUIInteraction(eventName, startedAt, sourceElem) {
     // this is throttled by instrumentation so that it isn't excessively called
@@ -115,7 +108,7 @@ export class Aggregate extends AggregateBase {
   setClosureHandlers() {
     this.interactionInProgress.on('finished', () => {
       const ref = this.interactionInProgress;
-      this.interactionsToHarvest.push(this.interactionInProgress);
+      this.interactionsToHarvest.add(this.interactionInProgress);
       this.interactionInProgress = null;
       this.domObserver.disconnect(); // can stop observing whenever our interaction logic completes a cycle
 
@@ -142,9 +135,9 @@ export class Aggregate extends AggregateBase {
     */
     if (this.interactionInProgress?.isActiveDuring(timestamp)) return this.interactionInProgress;
     let saveIxn;
-    for (let idx = this.interactionsToHarvest.length - 1; idx >= 0; idx--) {
+    for (let idx = this.interactionsToHarvest.buffer.length - 1; idx >= 0; idx--) {
       // reverse search for the latest completed interaction for efficiency
-      const finishedInteraction = this.interactionsToHarvest[idx];
+      const finishedInteraction = this.interactionsToHarvest.buffer[idx];
       if (finishedInteraction.isActiveDuring(timestamp)) {
         if (finishedInteraction.trigger !== 'initialPageLoad') 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
@@ -204,10 +197,9 @@ export class Aggregate extends AggregateBase {
   #registerApiHandlers() {
     const INTERACTION_API = 'api-ixn-';
     const thisClass = this;
-    registerHandler(INTERACTION_API + 'get', function (time) {
-      let {
-        waitForEnd
-      } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    registerHandler(INTERACTION_API + 'get', function (time, {
+      waitForEnd
+    } = {}) {
       // 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);

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

@@ -3,7 +3,7 @@ import { Interaction } from './interaction';
 import { numeric } from '../../../common/serialize/bel-serializer';
 import { firstPaint } from '../../../common/vitals/first-paint';
 import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint';
-import { getInfo } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
 export class InitialPageLoadInteraction extends Interaction {
   constructor(agentIdentifier) {
     super(agentIdentifier, 'initialPageLoad', 0, null);

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

@@ -1,4 +1,4 @@
-import { getInfo } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
 import { globalScope, initialLocation } from '../../../common/constants/runtime';
 import { generateUuid } from '../../../common/ids/unique-id';
 import { addCustomAttributes, getAddStringContext, nullable, numeric } from '../../../common/serialize/bel-serializer';
@@ -11,10 +11,10 @@ import { BelNode } from './bel-node';
  * link https://github.com/newrelic/nr-querypack/blob/main/schemas/bel/7.qpschema
  **/
 export class Interaction extends BelNode {
-  id = (() => generateUuid())(); // unique id that is serialized and used to link interactions with errors
-  initialPageURL = (() => initialLocation)();
-  oldURL = (() => '' + globalScope?.location)();
-  newURL = (() => '' + globalScope?.location)();
+  id = generateUuid(); // unique id that is serialized and used to link interactions with errors
+  initialPageURL = initialLocation;
+  oldURL = '' + globalScope?.location;
+  newURL = '' + globalScope?.location;
   customName;
   customAttributes = {};
   customDataByApi = {};
@@ -22,7 +22,7 @@ export class Interaction extends BelNode {
   appTime; // only used by initialPageLoad interactions
   newRoute;
   /** Internal state of this interaction: in-progress, finished, or cancelled. */
-  status = (() => INTERACTION_STATUS.IP)();
+  status = INTERACTION_STATUS.IP;
   domTimestamp = 0;
   historyTimestamp = 0;
   createdByApi = false;
@@ -65,8 +65,7 @@ export class Interaction extends BelNode {
     else this.#cancel();
     return true;
   }
-  #finish() {
-    let customEndTime = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  #finish(customEndTime = 0) {
     if (this.status !== 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);

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

@@ -1,25 +1,26 @@
-import { originals } from '../../../common/config/config';
+import { gosNREUMOriginals } from '../../../common/window/nreum';
 import { isBrowserScope } from '../../../common/constants/runtime';
 import { handle } from '../../../common/event-emitter/handle';
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
 import { debounce } from '../../../common/util/invoke';
-import { wrapEvents, wrapHistory } from '../../../common/wrap';
+import { wrapEvents } from '../../../common/wrap/wrap-events';
+import { wrapHistory } from '../../../common/wrap/wrap-history';
 import { InstrumentBase } from '../../utils/instrument-base';
 import { FEATURE_NAME, INTERACTION_TRIGGERS } from '../constants';
 import { now } from '../../../common/timing/now';
 
-/** The minimal time after a UI event for which no further events will be processed - i.e. a throttling rate to reduce spam.
+/**
+ * The minimal time after a UI event for which no further events will be processed - i.e. a throttling rate to reduce spam.
  * This also give some time for the new interaction to complete without being discarded by a subsequent UI event and wrongly attributed.
  * This value is still subject to change and critique, as it is derived from beyond worst case time to next frame of a page.
  */
 const UI_WAIT_INTERVAL = 1 / 10 * 1000; // assume 10 fps
 
 export class Instrument extends InstrumentBase {
-  static featureName = (() => FEATURE_NAME)();
-  constructor(agentIdentifier, aggregator) {
-    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
-    if (!isBrowserScope || !originals.MO) return; // soft navigations is not supported outside web env or browsers without the mutation observer API
+    if (!isBrowserScope || !gosNREUMOriginals().o.MO) return; // soft navigations is not supported outside web env or browsers without the mutation observer API
 
     const historyEE = wrapHistory(this.ee);
     const eventsEE = wrapEvents(this.ee);
@@ -32,7 +33,7 @@ export class Instrument extends InstrumentBase {
     const trackURLChangeEvent = evt => handle('newURL', [evt.timeStamp, '' + window.location], undefined, this.featureName, this.ee);
     windowAddEventListener('popstate', trackURLChangeEvent, true, this.removeOnAbort?.signal);
     let oncePerFrame = false; // attempt to reduce dom noice since the observer runs very frequently with below options
-    const domObserver = new originals.MO((domChanges, observer) => {
+    const domObserver = new (gosNREUMOriginals().o.MO)((domChanges, observer) => {
       if (oncePerFrame) return;
       oncePerFrame = true;
       requestAnimationFrame(() => {
@@ -52,8 +53,7 @@ export class Instrument extends InstrumentBase {
     }, UI_WAIT_INTERVAL, {
       leading: true
     });
-    eventsEE.on('fn-start', _ref => {
-      let [evt] = _ref;
+    eventsEE.on('fn-start', ([evt]) => {
       // set up a new user ixn before the callback for the triggering event executes
       if (INTERACTION_TRIGGERS.includes(evt?.type)) {
         processUserInteraction(evt);
@@ -70,4 +70,5 @@ export class Instrument extends InstrumentBase {
       this.abortHandler = undefined; // weakly allow this abort op to run only once
     }
   }
-}
+}
+export const SoftNav = Instrument;

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

@@ -9,7 +9,8 @@ import { shouldCollectEvent } from '../../../common/deny-list/deny-list';
 import { navTimingValues as navTiming } from '../../../common/timing/nav-timing';
 import { generateUuid } from '../../../common/ids/unique-id';
 import { Interaction } from './interaction';
-import { getConfigurationValue, getRuntime } from '../../../common/config/config';
+import { getConfigurationValue } from '../../../common/config/init';
+import { getRuntime } from '../../../common/config/runtime';
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { Serializer } from './serializer';
@@ -25,6 +26,7 @@ import { handle } from '../../../common/event-emitter/handle';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { deregisterDrain } from '../../../common/drain/drain';
 import { warn } from '../../../common/util/console';
+import { EventBuffer } from '../../utils/event-buffer';
 const {
   FEATURE_NAME,
   INTERACTION_EVENTS,
@@ -44,7 +46,7 @@ const {
   originalSetTimeout
 } = CONSTANTS;
 export class Aggregate extends AggregateBase {
-  static featureName = (() => FEATURE_NAME)();
+  static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
     const agentRuntime = getRuntime(agentIdentifier);
@@ -62,8 +64,7 @@ export class Aggregate extends AggregateBase {
       childTime: 0,
       depth: 0,
       harvestTimeSeconds: getConfigurationValue(agentIdentifier, 'spa.harvestTimeSeconds') || 10,
-      interactionsToHarvest: [],
-      interactionsSent: [],
+      interactionsToHarvest: new EventBuffer(),
       // The below feature flag is used to disable the SPA ajax fix for specific customers, see https://new-relic.atlassian.net/browse/NR-172169
       disableSpaFix: (getConfigurationValue(agentIdentifier, 'feature_flags') || []).indexOf('disable-spa-fix') > -1
     };
@@ -116,8 +117,7 @@ export class Aggregate extends AggregateBase {
     //  | click ending:                   |   65  |    50    |        |           |           |
     // click fn-end                       |   70  |    0     |    0   |     70    |     20    |
 
-    this.waitForFlags(['spa']).then(_ref => {
-      let [spaFlag] = _ref;
+    this.waitForFlags(['spa']).then(([spaFlag]) => {
       if (spaFlag) {
         scheduler = new HarvestScheduler('events', {
           onFinished: onHarvestFinished,
@@ -619,14 +619,9 @@ export class Aggregate extends AggregateBase {
     }
     const classThis = this;
     function onHarvestStarted(options) {
-      if (state.interactionsToHarvest.length === 0 || classThis.blocked) return {};
-      var payload = serializer.serializeMultiple(state.interactionsToHarvest, 0, navTiming);
-      if (options.retry) {
-        state.interactionsToHarvest.forEach(function (interaction) {
-          state.interactionsSent.push(interaction);
-        });
-      }
-      state.interactionsToHarvest = [];
+      if (!state.interactionsToHarvest.hasData || classThis.blocked) return {};
+      var payload = serializer.serializeMultiple(state.interactionsToHarvest.buffer, 0, navTiming);
+      if (options.retry) state.interactionsToHarvest.hold();else state.interactionsToHarvest.clear();
       return {
         body: {
           e: payload
@@ -634,12 +629,7 @@ export class Aggregate extends AggregateBase {
       };
     }
     function onHarvestFinished(result) {
-      if (result.sent && result.retry && state.interactionsSent.length > 0) {
-        state.interactionsSent.forEach(function (interaction) {
-          state.interactionsToHarvest.unshift(interaction);
-        });
-        state.interactionsSent = [];
-      }
+      if (result.sent && result.retry && state.interactionsToHarvest.held.hasData) state.interactionsToHarvest.unhold();else state.interactionsToHarvest.held.clear();
     }
     baseEE.on('spa-jserror', function (type, name, params, metrics) {
       if (!state.currentNode) return;
@@ -687,7 +677,7 @@ export class Aggregate extends AggregateBase {
         interaction.root.attrs.firstContentfulPaint = firstContentfulPaint.current.value;
       }
       baseEE.emit('interactionDone', [interaction, true]);
-      state.interactionsToHarvest.push(interaction);
+      state.interactionsToHarvest.add(interaction);
       let smCategory;
       if (interaction.root?.attrs?.trigger === 'initialPageLoad') smCategory = 'InitialPageLoad';else if (interaction.routeChange) smCategory = 'RouteChange';else smCategory = 'Custom';
       handle(SUPPORTABILITY_METRIC_CHANNEL, ["Spa/Interaction/".concat(smCategory, "/Duration/Ms"), Math.max((interaction.root?.end || 0) - (interaction.root?.start || 0), 0)], undefined, FEATURE_NAMES.metrics, baseEE);

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

@@ -3,11 +3,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { getInfo, getRuntime, originals } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
+import { getRuntime } from '../../../common/config/runtime';
+import { gosNREUMOriginals } from '../../../common/window/nreum';
 import { ee } from '../../../common/event-emitter/contextual-ee';
 import { InteractionNode } from './interaction-node';
-var originalSetTimeout = originals.ST;
-var originalClearTimeout = originals.CT;
+var originalSetTimeout = gosNREUMOriginals().o.ST;
+var originalClearTimeout = gosNREUMOriginals().o.CT;
 var lastId = {};
 export function Interaction(eventName, timestamp, url, routeName, onFinished, agentIdentifier) {
   this.agentIdentifier = agentIdentifier;
@@ -81,8 +83,7 @@ InteractionPrototype.finish = function finishInteraction() {
   if (this.onFinished) {
     this.onFinished(this);
   }
-  Object.entries(getInfo(interaction.agentIdentifier).jsAttributes || {}).forEach(_ref => {
-    let [attr, value] = _ref;
+  Object.entries(getInfo(interaction.agentIdentifier).jsAttributes || {}).forEach(([attr, value]) => {
     if (!(attr in customAttrs)) customAttrs[attr] = value;
   });
   root.end = endTimestamp;

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

@@ -5,7 +5,7 @@
 import { cleanURL } from '../../../common/url/clean-url';
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
 import { SharedContext } from '../../../common/context/shared-context';
-import { getInfo } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
 export class Serializer extends SharedContext {
   constructor(parent) {
     super(parent);

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

@@ -1,4 +1,4 @@
-import { originals } from '../../common/config/config';
+import { gosNREUMOriginals } from '../../common/window/nreum';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 export const FEATURE_NAME = FEATURE_NAMES.spa;
 export const INTERACTION_EVENTS = ['click', 'submit', 'keypress', 'keydown', 'keyup', 'change'];
@@ -15,7 +15,7 @@ export const FETCH_START = 'fetch-start';
 export const FETCH_DONE = 'fetch-done';
 export const FETCH_BODY = 'fetch-body-';
 export const JSONP_END = 'jsonp-end';
-export const originalSetTimeout = originals.ST;
+export const originalSetTimeout = gosNREUMOriginals().o.ST;
 export const START = '-start';
 export const END = '-end';
 export const BODY = '-body';