@newrelic/browser-agent 1.269.0 → 1.270.1

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

@@ -1,13 +1,9 @@
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
-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';
 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';
@@ -17,14 +13,12 @@ const ERROR_MODE_SECONDS_WINDOW = 30 * 1000; // sliding window of nodes to track
 const QUERY_PARAM_PADDING = 5000;
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator) {
-    super(agentIdentifier, aggregator, FEATURE_NAME);
-    this.agentRuntime = getRuntime(agentIdentifier);
-    this.agentInfo = getInfo(agentIdentifier);
+  constructor(agentRef) {
+    super(agentRef, FEATURE_NAME);
 
     /** A buffer to hold on to harvested traces in the case that a retry must be made later */
     this.sentTrace = null;
-    this.harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'session_trace.harvestTimeSeconds') || 30;
+    this.harvestTimeSeconds = agentRef.init.session_trace.harvestTimeSeconds || 30;
     /** Tied to the entitlement flag response from BCS.  Will short circuit operations of the agg if false  */
     this.entitled = undefined;
     /** A flag used to decide if the 30 node threshold should be ignored on the first harvest to ensure sending on the first payload */
@@ -40,12 +34,12 @@ export class Aggregate extends AggregateBase {
   /** 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) {
     this.entitled ??= stEntitled;
-    if (this.blocked || !this.entitled) return deregisterDrain(this.agentIdentifier, this.featureName);
+    if (this.blocked || !this.entitled) return this.deregisterDrain();
     if (!this.initialized) {
       this.initialized = true;
       /** Store session identifiers at initialization time to be cross-checked later at harvest time for session changes that are subject to race conditions */
-      this.ptid = this.agentRuntime.ptid;
-      this.sessionId = this.agentRuntime.session?.state.value;
+      this.ptid = this.agentRef.runtime.ptid;
+      this.sessionId = this.agentRef.runtime.session?.state.value;
       // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
       this.ee.on(SESSION_EVENTS.RESET, () => {
         if (this.blocked) return;
@@ -69,12 +63,12 @@ export class Aggregate extends AggregateBase {
 
     /** ST/SR sampling flow in BCS - https://drive.google.com/file/d/19hwt2oft-8Hh4RrjpLqEXfpP_9wYBLcq/view?usp=sharing */
     /** ST will run in the mode provided by BCS if the session IS NEW.  If not... it will use the state of the session entity to determine what mode to run in */
-    if (!this.agentRuntime.session.isNew && !ignoreSession) this.mode = this.agentRuntime.session.state.sessionTraceMode;else this.mode = stMode;
+    if (!this.agentRef.runtime.session.isNew && !ignoreSession) this.mode = this.agentRef.runtime.session.state.sessionTraceMode;else this.mode = stMode;
 
     /** If the mode is off, we do not want to hold up draining for other features, so we deregister the feature for now.
      * If it drains later (due to a mode change), data and handlers will instantly drain instead of waiting for the registry. */
-    if (this.mode === MODE.OFF) return deregisterDrain(this.agentIdentifier, this.featureName);
-    this.timeKeeper ??= this.agentRuntime.timeKeeper;
+    if (this.mode === MODE.OFF) return this.deregisterDrain();
+    this.timeKeeper ??= this.agentRef.runtime.timeKeeper;
     this.scheduler = new HarvestScheduler('browser/blobs', {
       onFinished: this.onHarvestFinished.bind(this),
       retryDelay: this.harvestTimeSeconds,
@@ -98,7 +92,7 @@ export class Aggregate extends AggregateBase {
         if (this.mode === MODE.ERROR) this.switchToFull();
       }, this.featureName, this.ee);
     }
-    this.agentRuntime.session.write({
+    this.agentRef.runtime.session.write({
       sessionTraceMode: this.mode
     });
     this.drain();
@@ -116,7 +110,7 @@ export class Aggregate extends AggregateBase {
     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;
-    if (this.sessionId !== this.agentRuntime.session?.state.value || this.ptid !== this.agentRuntime.ptid) return this.abort(3); // if something unexpected happened and we somehow still got to the point of harvesting after a session identifier changed, we should force-exit instead of harvesting
+    if (this.sessionId !== this.agentRef.runtime.session?.state.value || this.ptid !== this.agentRef.runtime.ptid) return this.abort(3); // if something unexpected happened and we somehow still got to the point of harvesting after a session identifier changed, we should force-exit instead of harvesting
     /** Get the ST nodes from the traceStorage buffer.  This also returns helpful metadata about the payload. */
     const {
       stns,
@@ -127,12 +121,12 @@ export class Aggregate extends AggregateBase {
     if (options.retry) {
       this.sentTrace = stns;
     }
-    const firstSessionHarvest = !this.agentRuntime.session.state.traceHarvestStarted;
-    if (firstSessionHarvest) this.agentRuntime.session.write({
+    const firstSessionHarvest = !this.agentRef.runtime.session.state.traceHarvestStarted;
+    if (firstSessionHarvest) this.agentRef.runtime.session.write({
       traceHarvestStarted: true
     });
-    const hasReplay = this.agentRuntime.session?.state.sessionReplayMode === 1;
-    const endUserId = this.agentInfo?.jsAttributes?.['enduser.id'];
+    const hasReplay = this.agentRef.runtime.session?.state.sessionReplayMode === 1;
+    const endUserId = this.agentRef.info?.jsAttributes?.['enduser.id'];
     this.everHarvested = true;
 
     /** The blob consumer expects the following and will reject if not supplied:
@@ -144,19 +138,19 @@ export class Aggregate extends AggregateBase {
      *
      * For data that does not fit the schema of the above, it should be url-encoded and placed into `attributes`
      */
-    const agentMetadata = this.agentRuntime.appMetadata?.agents?.[0] || {};
+    const agentMetadata = this.agentRef.runtime.appMetadata?.agents?.[0] || {};
     return {
       qs: {
-        browser_monitoring_key: this.agentInfo.licenseKey,
+        browser_monitoring_key: this.agentRef.info.licenseKey,
         type: 'BrowserSessionChunk',
-        app_id: this.agentInfo.applicationID,
+        app_id: this.agentRef.info.applicationID,
         protocol_version: '0',
         timestamp: Math.floor(this.timeKeeper.correctRelativeTimestamp(earliestTimeStamp)),
         attributes: encodeObj({
           ...(agentMetadata.entityGuid && {
             entityGuid: agentMetadata.entityGuid
           }),
-          harvestId: "".concat(this.agentRuntime.session?.state.value, "_").concat(this.agentRuntime.ptid, "_").concat(this.agentRuntime.harvestCount),
+          harvestId: "".concat(this.agentRef.runtime.session?.state.value, "_").concat(this.agentRef.runtime.ptid, "_").concat(this.agentRef.runtime.harvestCount),
           // 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
@@ -165,7 +159,7 @@ export class Aggregate extends AggregateBase {
           'trace.nodes': stns.length,
           'trace.originTimestamp': this.timeKeeper.correctedOriginTime,
           // other payload metadata
-          agentVersion: this.agentRuntime.version,
+          agentVersion: this.agentRef.runtime.version,
           ...(firstSessionHarvest && {
             firstSessionHarvest
           }),
@@ -204,7 +198,7 @@ export class Aggregate extends AggregateBase {
     if (this.mode === MODE.FULL || !this.entitled || this.blocked) return;
     const prevMode = this.mode;
     this.mode = MODE.FULL;
-    this.agentRuntime.session.write({
+    this.agentRef.runtime.session.write({
       sessionTraceMode: this.mode
     });
     if (prevMode === MODE.OFF || !this.initialized) return this.initialize(this.mode, this.entitled);
@@ -218,7 +212,7 @@ export class Aggregate extends AggregateBase {
   abort(reason) {
     this.blocked = true;
     this.mode = MODE.OFF;
-    this.agentRuntime.session.write({
+    this.agentRef.runtime.session.write({
       sessionTraceMode: this.mode
     });
     this.scheduler?.stopTimer();

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

@@ -46,7 +46,7 @@ export class TraceStorage {
     if (this.parent.blocked) return;
     if (this.nodeCount >= MAX_NODES_PER_HARVEST) {
       // limit the amount of pending data awaiting next harvest
-      if (this.parent.agentRuntime.session.state.sessionTraceMode !== MODE.ERROR) return;
+      if (this.parent.mode !== MODE.ERROR) return;
       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;
     }

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

@@ -8,7 +8,6 @@ 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';
-import { deregisterDrain } from '../../../common/drain/drain';
 import { canEnableSessionTracking } from '../../utils/feature-gates';
 import { now } from '../../../common/timing/now';
 const {
@@ -23,11 +22,11 @@ const {
 } = CONSTANTS;
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
-    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+  constructor(agentRef, auto = true) {
+    super(agentRef, FEATURE_NAME, auto);
     const canTrackSession = canEnableSessionTracking(this.agentIdentifier);
     if (!canTrackSession) {
-      deregisterDrain(this.agentIdentifier, this.featureName);
+      this.deregisterDrain();
       return;
     }
     const thisInstrumentEE = this.ee;
@@ -63,7 +62,7 @@ export class Instrument extends InstrumentBase {
     } catch (e) {
       // Per NEWRELIC-8525, we don't have a fallback for capturing resources for older versions that don't support PO at this time.
     }
-    this.importAggregator({
+    this.importAggregator(agentRef, {
       resourceObserver: observer
     });
   }

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

@@ -1,5 +1,3 @@
-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';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
@@ -15,14 +13,14 @@ import { InitialPageLoadInteraction } from './initial-page-load-interaction';
 import { Interaction } from './interaction';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, {
+  constructor(agentRef, {
     domObserver
   }) {
-    super(agentIdentifier, aggregator, FEATURE_NAME);
-    const harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'soft_navigations.harvestTimeSeconds') || 10;
+    super(agentRef, FEATURE_NAME);
+    const harvestTimeSeconds = agentRef.init.soft_navigations.harvestTimeSeconds || 10;
     this.interactionsToHarvest = new EventBuffer();
     this.domObserver = domObserver;
-    this.initialPageLoadInteraction = new InitialPageLoadInteraction(agentIdentifier);
+    this.initialPageLoadInteraction = new InitialPageLoadInteraction(agentRef.agentIdentifier);
     timeToFirstByte.subscribe(({
       attrs
     }) => {
@@ -45,15 +43,12 @@ export class Aggregate extends AggregateBase {
           onFinished: this.onHarvestFinished.bind(this),
           retryDelay: harvestTimeSeconds,
           onUnload: () => this.interactionInProgress?.done() // return any held ajax or jserr events so they can be sent with EoL harvest
-        }, {
-          agentIdentifier,
-          ee: this.ee
-        });
+        }, this);
         scheduler.harvest.on('events', this.onHarvestStarted.bind(this));
         scheduler.startTimer(harvestTimeSeconds, 0);
       } else {
         this.blocked = true; // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
-        deregisterDrain(this.agentIdentifier, this.featureName);
+        this.deregisterDrain();
       }
     });
 

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

@@ -18,8 +18,8 @@ const UI_WAIT_INTERVAL = 1 / 10 * 1000; // assume 10 fps
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
-    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+  constructor(agentRef, auto = true) {
+    super(agentRef, FEATURE_NAME, auto);
     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);
@@ -61,7 +61,7 @@ export class Instrument extends InstrumentBase {
     });
     for (let eventType of INTERACTION_TRIGGERS) document.addEventListener(eventType, () => {/* no-op, this ensures the UI events are monitored by our callback above */});
     this.abortHandler = abort;
-    this.importAggregator({
+    this.importAggregator(agentRef, {
       domObserver
     });
     function abort() {

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

@@ -9,8 +9,6 @@ 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 } 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';
@@ -24,7 +22,6 @@ import { bundleId } from '../../../common/ids/bundle-id';
 import { loadedAsDeferredBrowserScript } from '../../../common/constants/runtime';
 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 {
@@ -47,12 +44,11 @@ const {
 } = CONSTANTS;
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator) {
-    super(agentIdentifier, aggregator, FEATURE_NAME);
-    const agentRuntime = getRuntime(agentIdentifier);
+  constructor(agentRef) {
+    super(agentRef, FEATURE_NAME);
     this.state = {
-      initialPageURL: agentRuntime.origin,
-      lastSeenUrl: agentRuntime.origin,
+      initialPageURL: agentRef.runtime.origin,
+      lastSeenUrl: agentRef.runtime.origin,
       lastSeenRouteName: null,
       timerMap: {},
       timerBudget: MAX_TIMER_BUDGET,
@@ -63,10 +59,10 @@ export class Aggregate extends AggregateBase {
       pageLoaded: false,
       childTime: 0,
       depth: 0,
-      harvestTimeSeconds: getConfigurationValue(agentIdentifier, 'spa.harvestTimeSeconds') || 10,
+      harvestTimeSeconds: agentRef.init.spa.harvestTimeSeconds || 10,
       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
+      disableSpaFix: (agentRef.init.feature_flags || []).indexOf('disable-spa-fix') > -1
     };
     let scheduler;
     this.serializer = new Serializer(this);
@@ -74,7 +70,7 @@ export class Aggregate extends AggregateBase {
       state,
       serializer
     } = this;
-    const baseEE = ee.get(agentIdentifier); // <-- parent baseEE
+    const baseEE = ee.get(agentRef.agentIdentifier); // <-- parent baseEE
     const mutationEE = baseEE.get('mutation');
     const promiseEE = baseEE.get('promise');
     const historyEE = baseEE.get('history');
@@ -122,19 +118,16 @@ export class Aggregate extends AggregateBase {
         scheduler = new HarvestScheduler('events', {
           onFinished: onHarvestFinished,
           retryDelay: state.harvestTimeSeconds
-        }, {
-          agentIdentifier,
-          ee: baseEE
-        });
+        }, this);
         scheduler.harvest.on('events', onHarvestStarted);
         this.drain();
       } else {
         this.blocked = true;
-        deregisterDrain(this.agentIdentifier, this.featureName);
+        this.deregisterDrain();
       }
     });
-    if (!isEnabled()) return;
-    state.initialPageLoad = new Interaction('initialPageLoad', 0, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier);
+    if (agentRef.init.spa.enabled !== true) return;
+    state.initialPageLoad = new Interaction('initialPageLoad', 0, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier);
     state.initialPageLoad.save = true;
     state.prevInteraction = state.initialPageLoad;
     state.currentNode = state.initialPageLoad.root; // hint
@@ -215,7 +208,7 @@ export class Aggregate extends AggregateBase {
         // Otherwise, if no interaction is currently active, create a new node ID,
         // and let the aggregator know that we entered a new event handler callback
         // so that it has a chance to possibly start an interaction.
-        var ixn = new Interaction(evName, this[FN_START], state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier);
+        var ixn = new Interaction(evName, this[FN_START], state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier);
 
         // Store the interaction as prevInteraction in case it is prematurely discarded
         state.prevInteraction = ixn;
@@ -306,7 +299,7 @@ export class Aggregate extends AggregateBase {
         this.sent = true;
         node.dt = this.dt;
         if (node.dt?.timestamp) {
-          node.dt.timestamp = agentRuntime.timeKeeper.correctAbsoluteTimestamp(node.dt.timestamp);
+          node.dt.timestamp = agentRef.runtime.timeKeeper.correctAbsoluteTimestamp(node.dt.timestamp);
         }
         node.jsEnd = node.start = this.startTime;
         node[INTERACTION][REMAINING]++;
@@ -395,7 +388,7 @@ export class Aggregate extends AggregateBase {
           if (dtPayload && this[SPA_NODE]) {
             this[SPA_NODE].dt = dtPayload;
             if (this[SPA_NODE].dt?.timestamp) {
-              this[SPA_NODE].dt.timestamp = agentRuntime.timeKeeper.correctAbsoluteTimestamp(this[SPA_NODE].dt.timestamp);
+              this[SPA_NODE].dt.timestamp = agentRef.runtime.timeKeeper.correctAbsoluteTimestamp(this[SPA_NODE].dt.timestamp);
             }
           }
         }
@@ -513,7 +506,7 @@ export class Aggregate extends AggregateBase {
     }, this.featureName, promiseEE);
     register(INTERACTION_API + 'get', function (t) {
       var interaction;
-      if (state?.currentNode?.[INTERACTION]) interaction = this.ixn = state.currentNode[INTERACTION];else if (state?.prevNode?.end === null && state?.prevNode?.[INTERACTION]?.root?.[INTERACTION]?.eventName !== 'initialPageLoad') interaction = this.ixn = state.prevNode[INTERACTION];else interaction = this.ixn = new Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier);
+      if (state?.currentNode?.[INTERACTION]) interaction = this.ixn = state.currentNode[INTERACTION];else if (state?.prevNode?.end === null && state?.prevNode?.[INTERACTION]?.root?.[INTERACTION]?.eventName !== 'initialPageLoad') interaction = this.ixn = state.prevNode[INTERACTION];else interaction = this.ixn = new Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier);
       if (!state.currentNode) {
         interaction.checkFinish();
         if (state.depth) setCurrentNode(interaction.root);
@@ -642,11 +635,11 @@ export class Aggregate extends AggregateBase {
     register('function-err', function (args, obj, error) {
       if (!state.currentNode) return;
       error.__newrelic ??= {};
-      error.__newrelic[agentIdentifier] = {
+      error.__newrelic[agentRef.agentIdentifier] = {
         interactionId: state.currentNode.interaction.id
       };
       if (state.currentNode.type && state.currentNode.type !== 'interaction') {
-        error.__newrelic[agentIdentifier].interactionNodeId = state.currentNode.id;
+        error.__newrelic[agentRef.agentIdentifier].interactionNodeId = state.currentNode.id;
       }
     }, this.featureName, baseEE);
     baseEE.on('interaction', saveInteraction);
@@ -684,9 +677,5 @@ export class Aggregate extends AggregateBase {
       scheduler?.scheduleHarvest(0);
       if (!scheduler) warn(19);
     }
-    function isEnabled() {
-      var enabled = getConfigurationValue(agentIdentifier, 'spa.enabled');
-      return enabled !== false;
-    }
   }
 }

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

@@ -33,8 +33,8 @@ const {
  */
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
-    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+  constructor(agentRef, auto = true) {
+    super(agentRef, FEATURE_NAME, auto);
     if (!isBrowserScope) return; // SPA not supported outside web env
 
     try {
@@ -58,7 +58,7 @@ export class Instrument extends InstrumentBase {
     promiseEE.on(CB_END, endTimestamp);
     jsonpEE.on(CB_END, endTimestamp);
     this.ee.on('fn-err', (...args) => {
-      if (!args[2]?.__newrelic?.[agentIdentifier]) handle('function-err', [...args], undefined, this.featureName, this.ee);
+      if (!args[2]?.__newrelic?.[agentRef.agentIdentifier]) handle('function-err', [...args], undefined, this.featureName, this.ee);
     });
     this.ee.buffer([FN_START, FN_END, 'xhr-resolved'], this.featureName);
     eventsEE.buffer([FN_START], this.featureName);
@@ -105,7 +105,7 @@ export class Instrument extends InstrumentBase {
       });
     }
     this.abortHandler = this.#abort;
-    this.importAggregator();
+    this.importAggregator(agentRef);
   }
 
   /** Restoration and resource release tasks to be done if SPA loader is being aborted. Unwind changes to globals and subscription to DOM events. */

package/dist/esm/features/utils/aggregate-base.js

@@ -1,16 +1,16 @@
 import { FeatureBase } from './feature-base';
-import { getInfo, isValid } from '../../common/config/info';
-import { getRuntime } from '../../common/config/runtime';
+import { isValid } from '../../common/config/info';
 import { configure } from '../../loaders/configure/configure';
 import { gosCDN } from '../../common/window/nreum';
-import { deregisterDrain, drain } from '../../common/drain/drain';
+import { drain } from '../../common/drain/drain';
 import { activatedFeatures } from '../../common/util/feature-flags';
 import { Obfuscator } from '../../common/util/obfuscate';
 export class AggregateBase extends FeatureBase {
-  constructor(...args) {
-    super(...args);
-    this.checkConfiguration();
-    this.obfuscator = getRuntime(this.agentIdentifier).obfuscator;
+  constructor(agentRef, featureName) {
+    super(agentRef.agentIdentifier, featureName);
+    this.agentRef = agentRef;
+    this.checkConfiguration(agentRef);
+    this.obfuscator = agentRef.runtime.obfuscator;
   }
 
   /**
@@ -37,7 +37,7 @@ export class AggregateBase extends FeatureBase {
     return flagsPromise.catch(err => {
       this.ee.emit('internal-error', [err]);
       this.blocked = true;
-      deregisterDrain(this.agentIdentifier, this.featureName);
+      this.deregisterDrain();
     });
   }
   drain() {
@@ -49,7 +49,7 @@ export class AggregateBase extends FeatureBase {
    * Checks for additional `jsAttributes` items to support backward compatibility with implementations of the agent where
    * loader configurations may appear after the loader code is executed.
    */
-  checkConfiguration() {
+  checkConfiguration(existingAgent) {
     // NOTE: This check has to happen at aggregator load time
     if (!isValid(this.agentIdentifier)) {
       const cdn = gosCDN();
@@ -59,7 +59,7 @@ export class AggregateBase extends FeatureBase {
       try {
         jsAttributes = {
           ...jsAttributes,
-          ...getInfo(this.agentIdentifier)?.jsAttributes
+          ...existingAgent.info?.jsAttributes
         };
       } catch (err) {
         // do nothing
@@ -72,12 +72,11 @@ export class AggregateBase extends FeatureBase {
           ...cdn.info,
           jsAttributes
         },
-        runtime: getRuntime(this.agentIdentifier)
+        runtime: existingAgent.runtime
       });
     }
-    const runtime = getRuntime(this.agentIdentifier);
-    if (!runtime.obfuscator) {
-      runtime.obfuscator = new Obfuscator(this.agentIdentifier);
+    if (!existingAgent.runtime.obfuscator) {
+      existingAgent.runtime.obfuscator = new Obfuscator(this.agentIdentifier);
     }
   }
 }

package/dist/esm/features/utils/feature-base.js

@@ -1,10 +1,9 @@
 import { ee } from '../../common/event-emitter/contextual-ee';
+import { deregisterDrain } from '../../common/drain/drain';
 export class FeatureBase {
-  constructor(agentIdentifier, aggregator, featureName) {
+  constructor(agentIdentifier, featureName) {
     /** @type {string} */
     this.agentIdentifier = agentIdentifier;
-    /** @type {import('../../common/aggregate/aggregator').Aggregator} */
-    this.aggregator = aggregator;
     /** @type {import('../../common/event-emitter/contextual-ee').ee} */
     this.ee = ee.get(agentIdentifier);
     /** @type {string} */
@@ -16,4 +15,7 @@ export class FeatureBase {
      */
     this.blocked = false;
   }
+  deregisterDrain() {
+    deregisterDrain(this.agentIdentifier, this.featureName);
+  }
 }

package/dist/esm/features/utils/instrument-base.js

@@ -10,7 +10,6 @@ import { onWindowLoad } from '../../common/window/load';
 import { isBrowserScope } from '../../common/constants/runtime';
 import { warn } from '../../common/util/console';
 import { FEATURE_NAMES } from '../../loaders/features/features';
-import { getConfigurationValue } from '../../common/config/init';
 import { hasReplayPrerequisite } from '../session_replay/shared/utils';
 import { canEnableSessionTracking } from './feature-gates';
 import { single } from '../../common/util/invoke';
@@ -23,14 +22,13 @@ export class InstrumentBase extends FeatureBase {
   /**
    * Instantiate InstrumentBase.
    * @param {string} agentIdentifier - The unique ID of the instantiated agent (relative to global scope).
-   * @param {import('../../common/aggregate/aggregator').Aggregator} aggregator - The shared Aggregator that will handle batching and reporting of data.
    * @param {string} featureName - The name of the feature module (used to construct file path).
    * @param {boolean} [auto=true] - Determines whether the feature should automatically register to have the draining
    *     of its pooled instrumentation data handled by the agent's centralized drain functionality, rather than draining
    *     immediately. Primarily useful for fine-grained control in tests.
    */
-  constructor(agentIdentifier, aggregator, featureName, auto = true) {
-    super(agentIdentifier, aggregator, featureName);
+  constructor(agentRef, featureName, auto = true) {
+    super(agentRef.agentIdentifier, featureName);
     this.auto = auto;
 
     /** @type {Function | undefined} This should be set by any derived Instrument class if it has things to do when feature fails or is killed. */
@@ -50,15 +48,15 @@ export class InstrumentBase extends FeatureBase {
     this.onAggregateImported = undefined;
 
     /** used in conjunction with newrelic.start() to defer harvesting in features */
-    if (getConfigurationValue(this.agentIdentifier, "".concat(this.featureName, ".autoStart")) === false) this.auto = false;
+    if (agentRef.init[this.featureName].autoStart === false) this.auto = false;
     /** if the feature requires opt-in (!auto-start), it will get registered once the api has been called */
-    if (this.auto) registerDrain(agentIdentifier, featureName);else {
+    if (this.auto) registerDrain(agentRef.agentIdentifier, featureName);else {
       this.ee.on('manual-start-all', single(() => {
         // register the feature to drain only once the API has been called, it will drain when importAggregator finishes for all the features
         // called by the api in that cycle
-        registerDrain(this.agentIdentifier, this.featureName);
+        registerDrain(agentRef.agentIdentifier, this.featureName);
         this.auto = true;
-        this.importAggregator();
+        this.importAggregator(agentRef);
       }));
     }
   }
@@ -66,10 +64,11 @@ export class InstrumentBase extends FeatureBase {
   /**
    * Lazy-load the latter part of the feature: its aggregator. This method is called by the first part of the feature
    * (the instrumentation) when instrumentation is complete.
+   * @param agentRef - reference to the base agent ancestor that this feature belongs to
    * @param {Object} [argsObjFromInstrument] - any values or references to pass down to aggregate
    * @returns void
    */
-  importAggregator(argsObjFromInstrument = {}) {
+  importAggregator(agentRef, argsObjFromInstrument = {}) {
     if (this.featAggregate || !this.auto) return;
     let loadedSuccessfully;
     this.onAggregateImported = new Promise(resolve => {
@@ -91,6 +90,15 @@ export class InstrumentBase extends FeatureBase {
         if (this.featureName === FEATURE_NAMES.sessionReplay) this.abortHandler?.(); // SR should stop recording if session DNE
       }
 
+      // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
+      if (!agentRef.sharedAggregator) {
+        agentRef.sharedAggregator = import(/* webpackChunkName: "shared-aggregator" */'../../common/aggregate/aggregator');
+        const {
+          Aggregator
+        } = await agentRef.sharedAggregator;
+        agentRef.sharedAggregator = new Aggregator();
+      } else await agentRef.sharedAggregator; // if another feature is already importing the aggregator, wait for it to finish
+
       /**
        * Note this try-catch differs from the one in Agent.run() in that it's placed later in a page's lifecycle and
        * it's only responsible for aborting its one specific feature, rather than all.
@@ -107,7 +115,7 @@ export class InstrumentBase extends FeatureBase {
         const {
           Aggregate
         } = await lazyFeatureLoader(this.featureName, 'aggregate');
-        this.featAggregate = new Aggregate(this.agentIdentifier, this.aggregator, argsObjFromInstrument);
+        this.featAggregate = new Aggregate(agentRef, argsObjFromInstrument);
         loadedSuccessfully(true);
       } catch (e) {
         warn(34, e);

package/dist/esm/loaders/agent.js

@@ -10,7 +10,6 @@ import { featurePriority, FEATURE_NAMES } from './features/features';
 // required features
 import { Instrument as PageViewEvent } from '../features/page_view_event/instrument';
 // common files
-import { Aggregator } from '../common/aggregate/aggregator';
 import { gosNREUM, setNREUMInitializedAgent } from '../common/window/nreum';
 import { warn } from '../common/util/console';
 import { globalScope } from '../common/constants/runtime';
@@ -32,9 +31,6 @@ export class Agent extends AgentBase {
       warn(21);
       return;
     }
-    this.sharedAggregator = new Aggregator({
-      agentIdentifier: this.agentIdentifier
-    });
     this.features = {};
     setNREUMInitializedAgent(this.agentIdentifier, this); // append this agent onto the global NREUM.initializedAgents
 
@@ -74,7 +70,7 @@ export class Agent extends AgentBase {
             missingDependencies
           });
         }
-        this.features[InstrumentCtor.featureName] = new InstrumentCtor(this.agentIdentifier, this.sharedAggregator);
+        this.features[InstrumentCtor.featureName] = new InstrumentCtor(this);
       });
     } catch (err) {
       warn(22, err);