@newrelic/browser-agent 1.288.1 → 1.289.0

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

@@ -2,22 +2,17 @@
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getConfiguration, getConfigurationValue } from '../../../common/config/init';
-import { getLoaderConfig } from '../../../common/config/loader-config';
 import { generateSpanId, generateTraceId } from '../../../common/ids/unique-id';
 import { parseUrl } from '../../../common/url/parse-url';
 import { globalScope } from '../../../common/constants/runtime';
 import { stringify } from '../../../common/util/stringify';
 export class DT {
-  constructor(agentIdentifier) {
-    this.agentIdentifier = agentIdentifier;
+  constructor(agentRef) {
+    this.agentRef = agentRef;
   }
   generateTracePayload(parsedOrigin) {
-    if (!this.shouldGenerateTrace(parsedOrigin)) {
-      return null;
-    }
-    var loaderConfig = getLoaderConfig(this.agentIdentifier);
-    if (!loaderConfig) {
+    const loaderConfig = this.agentRef.loader_config;
+    if (!this.shouldGenerateTrace(parsedOrigin) || !loaderConfig) {
       return null;
     }
     var accountId = (loaderConfig.accountID || '').toString() || null;
@@ -79,18 +74,14 @@ export class DT {
   // return true if DT is enabled and the origin is allowed, either by being
   // same-origin, or included in the allowed list
   shouldGenerateTrace(parsedOrigin) {
-    return this.isDtEnabled() && this.isAllowedOrigin(parsedOrigin);
+    return this.agentRef.init?.distributed_tracing && this.isAllowedOrigin(parsedOrigin);
   }
   isAllowedOrigin(parsedOrigin) {
     var allowed = false;
-    var dtConfig = {};
-    var dt = getConfigurationValue(this.agentIdentifier, 'distributed_tracing');
-    if (dt) {
-      dtConfig = getConfiguration(this.agentIdentifier).distributed_tracing;
-    }
+    const dtConfig = this.agentRef.init?.distributed_tracing;
     if (parsedOrigin.sameOrigin) {
       allowed = true;
-    } else if (dtConfig.allowed_origins instanceof Array) {
+    } else if (dtConfig?.allowed_origins instanceof Array) {
       for (var i = 0; i < dtConfig.allowed_origins.length; i++) {
         var allowedOrigin = parseUrl(dtConfig.allowed_origins[i]);
         if (parsedOrigin.hostname === allowedOrigin.hostname && parsedOrigin.protocol === allowedOrigin.protocol && parsedOrigin.port === allowedOrigin.port) {
@@ -101,31 +92,24 @@ export class DT {
     }
     return allowed;
   }
-  isDtEnabled() {
-    var dt = getConfigurationValue(this.agentIdentifier, 'distributed_tracing');
-    if (dt) {
-      return !!dt.enabled;
-    }
-    return false;
-  }
 
   // exclude the newrelic header for same-origin calls
   excludeNewrelicHeader() {
-    var dt = getConfigurationValue(this.agentIdentifier, 'distributed_tracing');
+    var dt = this.agentRef.init?.distributed_tracing;
     if (dt) {
       return !!dt.exclude_newrelic_header;
     }
     return false;
   }
   useNewrelicHeaderForCors() {
-    var dt = getConfigurationValue(this.agentIdentifier, 'distributed_tracing');
+    var dt = this.agentRef.init?.distributed_tracing;
     if (dt) {
       return dt.cors_use_newrelic_header !== false;
     }
     return false;
   }
   useTraceContextHeadersForCors() {
-    var dt = getConfigurationValue(this.agentIdentifier, 'distributed_tracing');
+    var dt = this.agentRef.init?.distributed_tracing;
     if (dt) {
       return !!dt.cors_use_tracecontext_headers;
     }

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

@@ -28,7 +28,7 @@ export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef, auto = true) {
     super(agentRef, FEATURE_NAME, auto);
-    this.dt = new DT(agentRef.agentIdentifier);
+    this.dt = new DT(agentRef);
     this.handler = (type, args, ctx, group) => handle(type, args, ctx, group, this.ee);
 
     // this is a best (but imperfect) effort at capturing AJAX calls that may have fired before the agent was instantiated

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

@@ -19,7 +19,7 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
-    this.isSessionTrackingEnabled = canEnableSessionTracking(this.agentIdentifier) && this.agentRef.runtime.session;
+    this.isSessionTrackingEnabled = canEnableSessionTracking(agentRef.init) && agentRef.runtime.session;
 
     // 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, () => {

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

@@ -30,11 +30,11 @@ export class Aggregate extends AggregateBase {
     registerHandler('send-rum', (customAttibutes, target) => {
       this.sendRum(customAttibutes, target);
     }, this.featureName, this.ee);
-    if (!isValid(agentRef.agentIdentifier)) {
+    if (!isValid(agentRef.info)) {
       this.ee.abort();
       return warn(43);
     }
-    agentRef.runtime.timeKeeper = new TimeKeeper(agentRef.agentIdentifier);
+    agentRef.runtime.timeKeeper = new TimeKeeper(agentRef.runtime.session);
     if (isBrowserScope) {
       timeToFirstByte.subscribe(({
         value,

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

@@ -133,7 +133,7 @@ export class Aggregate extends AggregateBase {
 
   // serialize array of timing data
   serializer(eventBuffer) {
-    var addString = getAddStringContext(this.agentIdentifier);
+    var addString = getAddStringContext(this.agentRef.runtime.obfuscator);
     var payload = 'bel.6;';
     for (var i = 0; i < eventBuffer.length; i++) {
       var timing = eventBuffer[i];

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

@@ -45,7 +45,7 @@ export class Aggregate extends AggregateBase {
     this.recorder = args?.recorder;
     this.errorNoticed = args?.errorNoticed || false;
     this.harvestOpts.raw = true;
-    this.isSessionTrackingEnabled = canEnableSessionTracking(this.agentIdentifier) && !!this.agentRef.runtime.session;
+    this.isSessionTrackingEnabled = canEnableSessionTracking(agentRef.init) && !!agentRef.runtime.session;
     this.reportSupportabilityMetric('Config/SessionReplay/Enabled');
 
     // 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.

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

@@ -23,7 +23,7 @@ export class Instrument extends InstrumentBase {
     try {
       session = JSON.parse(localStorage.getItem("".concat(PREFIX, "_").concat(DEFAULT_KEY)));
     } catch (err) {}
-    if (hasReplayPrerequisite(agentRef.agentIdentifier)) {
+    if (hasReplayPrerequisite(agentRef.init)) {
       this.ee.on(SR_EVENT_EMITTER_TYPES.RECORD, () => this.#apiStartOrRestartReplay());
     }
     if (this.#canPreloadRecorder(session)) {
@@ -53,12 +53,12 @@ export class Instrument extends InstrumentBase {
       // this might be a new session if entity initializes: conservatively start recording if first-time config allows
       // Note: users with SR enabled, as well as these other configs enabled by-default, will be penalized by the recorder overhead EVEN IF they don't actually have or get
       // entitlement or sampling decision, or otherwise intentionally opted-in for the feature.
-      return isPreloadAllowed(this.agentIdentifier);
+      return isPreloadAllowed(this.#agentRef.init);
     } else if (session.sessionReplayMode === MODE.FULL || session.sessionReplayMode === MODE.ERROR) {
       return true; // existing sessions get to continue recording, regardless of this page's configs or if it has expired (conservatively)
     } else {
       // SR mode was OFF but may potentially be turned on if session resets and configs allows the new session to have replay...
-      return isPreloadAllowed(this.agentIdentifier);
+      return isPreloadAllowed(this.#agentRef.init);
     }
   }
   #alreadyStarted = false;

package/dist/esm/features/session_replay/shared/utils.js

@@ -3,18 +3,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { gosNREUMOriginals } from '../../../common/window/nreum';
-import { getConfigurationValue } from '../../../common/config/init';
 import { canEnableSessionTracking } from '../../utils/feature-gates';
 import { originTime } from '../../../common/constants/runtime';
-export function hasReplayPrerequisite(agentId) {
+export function hasReplayPrerequisite(agentInit) {
   return !!gosNREUMOriginals().o.MO &&
   // Session Replay cannot work without Mutation Observer
-  canEnableSessionTracking(agentId) &&
+  canEnableSessionTracking(agentInit) &&
   // requires session tracking to be running (hence "session" replay...)
-  getConfigurationValue(agentId, 'session_trace.enabled') === true; // Session Replay as of now is tightly coupled with Session Trace in the UI
+  agentInit?.session_trace.enabled === true; // Session Replay as of now is tightly coupled with Session Trace in the UI
 }
-export function isPreloadAllowed(agentId) {
-  return getConfigurationValue(agentId, 'session_replay.preload') === true && hasReplayPrerequisite(agentId);
+export function isPreloadAllowed(agentInit) {
+  return agentInit?.session_replay.preload === true && hasReplayPrerequisite(agentInit);
 }
 export function buildNRMetaNode(timestamp, timeKeeper) {
   const correctedTimestamp = timeKeeper.correctAbsoluteTimestamp(timestamp);

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

@@ -24,7 +24,7 @@ export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef, auto = true) {
     super(agentRef, FEATURE_NAME, auto);
-    const canTrackSession = canEnableSessionTracking(this.agentIdentifier);
+    const canTrackSession = canEnableSessionTracking(agentRef.init);
     if (!canTrackSession) {
       this.deregisterDrain();
       return;

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

@@ -6,8 +6,8 @@ import { addCustomAttributes, getAddStringContext, nullable, numeric } from '../
 import { NODE_TYPE } from '../constants';
 import { BelNode } from './bel-node';
 export class AjaxNode extends BelNode {
-  constructor(agentIdentifier, ajaxEvent) {
-    super(agentIdentifier);
+  constructor(agentRef, ajaxEvent) {
+    super(agentRef);
     this.belType = NODE_TYPE.AJAX;
     this.method = ajaxEvent.method;
     this.status = ajaxEvent.status;
@@ -24,7 +24,7 @@ export class AjaxNode extends BelNode {
     this.end = ajaxEvent.endTime;
   }
   serialize(parentStartTimestamp) {
-    const addString = getAddStringContext(this.agentIdentifier);
+    const addString = getAddStringContext(this.obfuscator);
     const nodeList = [];
 
     // IMPORTANT: The order in which addString is called matters and correlates to the order in which string shows up in the harvest payload. Do not re-order the following code.

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

@@ -12,9 +12,9 @@ export class BelNode {
   callbackEnd = 0;
   callbackDuration = 0;
   nodeId = ++nodesSeen;
-  constructor(agentIdentifier) {
-    if (!agentIdentifier) throw new Error('Interaction is missing core attributes');
-    this.agentIdentifier = agentIdentifier;
+  constructor(agentRef) {
+    this.obfuscator = agentRef.runtime.obfuscator;
+    this.info = agentRef.info;
   }
   addChild(child) {
     this.children.push(child);

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

@@ -20,7 +20,7 @@ export class Aggregate extends AggregateBase {
     super(agentRef, FEATURE_NAME);
     this.interactionsToHarvest = this.events;
     this.domObserver = domObserver;
-    this.initialPageLoadInteraction = new InitialPageLoadInteraction(agentRef.agentIdentifier);
+    this.initialPageLoadInteraction = new InitialPageLoadInteraction(agentRef);
     this.initialPageLoadInteraction.onDone.push(() => {
       // this ensures the .end() method also works with iPL
       if (agentRef.runtime.session?.isNew) this.initialPageLoadInteraction.customAttributes.isFirstOfSession = true; // mark the hard page load as first of its session
@@ -84,7 +84,7 @@ export class Aggregate extends AggregateBase {
     if (this.interactionInProgress?.done() === false) return; // current in-progress is blocked from closing, e.g. by 'waitForEnd' api option
 
     const oldURL = eventName === INTERACTION_TRIGGERS[3] ? this.latestHistoryUrl : undefined; // see related comment in 'newURL' handler above, 'popstate'
-    this.interactionInProgress = new Interaction(this.agentIdentifier, eventName, startedAt, this.latestRouteSetByApi, oldURL);
+    this.interactionInProgress = new Interaction(this.agentRef, eventName, startedAt, this.latestRouteSetByApi, oldURL);
     if (eventName === INTERACTION_TRIGGERS[0]) {
       // 'click'
       const sourceElemText = getActionText(sourceElem);
@@ -154,15 +154,15 @@ export class Aggregate extends AggregateBase {
       // no interaction was happening when this ajax started, so give it back to Ajax feature for processing
       handle('returnAjax', [event], undefined, FEATURE_NAMES.ajax, this.ee);
     } else {
-      if (associatedInteraction.status === INTERACTION_STATUS.FIN) processAjax(this.agentIdentifier, event, associatedInteraction); // tack ajax onto the ixn object awaiting harvest
+      if (associatedInteraction.status === INTERACTION_STATUS.FIN) processAjax(this.agentRef, event, associatedInteraction); // tack ajax onto the ixn object awaiting harvest
       else {
         // same thing as above, just at a later time -- if the interaction in progress is cancelled, just send the event back to ajax feat unmodified
-        associatedInteraction.on('finished', () => processAjax(this.agentIdentifier, event, associatedInteraction));
+        associatedInteraction.on('finished', () => processAjax(this.agentRef, event, associatedInteraction));
         associatedInteraction.on('cancelled', () => handle('returnAjax', [event], undefined, FEATURE_NAMES.ajax, this.ee));
       }
     }
-    function processAjax(agentId, event, parentInteraction) {
-      const newNode = new AjaxNode(agentId, event);
+    function processAjax(agent, event, parentInteraction) {
+      const newNode = new AjaxNode(agent, event);
       parentInteraction.addChild(newNode);
     }
   }
@@ -201,7 +201,7 @@ export class Aggregate extends AggregateBase {
       if (this.associatedInteraction?.trigger === IPL_TRIGGER_NAME) this.associatedInteraction = null; // the api get-interaction method cannot target IPL
       if (!this.associatedInteraction) {
         // This new api-driven interaction will be the target of any subsequent .interaction() call, until it is closed by EITHER .end() OR the regular seenHistoryAndDomChange process.
-        this.associatedInteraction = thisClass.interactionInProgress = new Interaction(thisClass.agentIdentifier, API_TRIGGER_NAME, time, thisClass.latestRouteSetByApi);
+        this.associatedInteraction = thisClass.interactionInProgress = new Interaction(thisClass.agentRef, API_TRIGGER_NAME, time, thisClass.latestRouteSetByApi);
         thisClass.domObserver.observe(document.body, {
           attributes: true,
           childList: true,

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

@@ -7,14 +7,12 @@ 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/info';
 import { IPL_TRIGGER_NAME } from '../constants';
 export class InitialPageLoadInteraction extends Interaction {
-  constructor(agentIdentifier) {
-    super(agentIdentifier, IPL_TRIGGER_NAME, 0, null);
-    const agentInfo = getInfo(agentIdentifier);
-    this.queueTime = agentInfo.queueTime;
-    this.appTime = agentInfo.applicationTime;
+  constructor(agentRef) {
+    super(agentRef, IPL_TRIGGER_NAME, 0, null);
+    this.queueTime = agentRef.info.queueTime;
+    this.appTime = agentRef.info.applicationTime;
   }
   get firstPaint() {
     return firstPaint.current.value;

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

@@ -2,7 +2,6 @@
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-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';
@@ -31,8 +30,8 @@ export class Interaction extends BelNode {
   keepOpenUntilEndApi = false;
   onDone = [];
   cancellationTimer;
-  constructor(agentIdentifier, uiEvent, uiEventTimestamp, currentRouteKnown, currentUrl) {
-    super(agentIdentifier);
+  constructor(agentRef, uiEvent, uiEventTimestamp, currentRouteKnown, currentUrl) {
+    super(agentRef);
     this.belType = NODE_TYPE.INTERACTION;
     this.trigger = uiEvent;
     this.start = uiEventTimestamp;
@@ -74,7 +73,7 @@ export class Interaction extends BelNode {
     clearTimeout(this.cancellationTimer);
     this.end = Math.max(this.domTimestamp, this.historyTimestamp, customEndTime);
     this.customAttributes = {
-      ...getInfo(this.agentIdentifier).jsAttributes,
+      ...this.info.jsAttributes,
       ...this.customAttributes
     }; // attrs specific to this interaction should have precedence over the general custom attrs
     this.status = INTERACTION_STATUS.FIN;
@@ -109,7 +108,7 @@ export class Interaction extends BelNode {
   get navTiming() {}
   serialize(firstStartTimeOfPayload) {
     const isFirstIxnOfPayload = firstStartTimeOfPayload === undefined;
-    const addString = getAddStringContext(this.agentIdentifier);
+    const addString = getAddStringContext(this.obfuscator);
     const nodeList = [];
     let ixnType;
     if (this.trigger === IPL_TRIGGER_NAME) ixnType = INTERACTION_TYPE.INITIAL_PAGE_LOAD;else if (this.newURL !== this.oldURL) ixnType = INTERACTION_TYPE.ROUTE_CHANGE;else ixnType = INTERACTION_TYPE.UNSPECIFIED;
@@ -127,7 +126,7 @@ export class Interaction extends BelNode {
     // not relative
     addString(this.trigger), addString(cleanURL(this.initialPageURL, true)), addString(cleanURL(this.oldURL, true)), addString(cleanURL(this.newURL, true)), addString(this.customName), ixnType, nullable(this.queueTime, numeric, true) + nullable(this.appTime, numeric, true) + nullable(this.oldRoute, addString, true) + nullable(this.newRoute, addString, true) + addString(this.id), addString(this.nodeId), nullable(this.firstPaint, numeric, true) + nullable(this.firstContentfulPaint, numeric)];
     const allAttachedNodes = addCustomAttributes(this.customAttributes || {}, addString); // start with all custom attributes
-    if (getInfo(this.agentIdentifier).atts) allAttachedNodes.push('a,' + addString(getInfo(this.agentIdentifier).atts)); // add apm provided attributes
+    if (this.info.atts) allAttachedNodes.push('a,' + addString(this.info.atts)); // add apm provided attributes
     /* Querypack encoder+decoder quirkiness:
        - If first ixn node of payload is being processed, its children's start time must be offset by this node's start. (firstStartTime should be undefined.)
        - Else for subsequent ixns in the same payload, we go back to using that first ixn node's start to offset their children's start. */

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

@@ -60,7 +60,7 @@ export class Aggregate extends AggregateBase {
       // 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: (agentRef.init.feature_flags || []).indexOf('disable-spa-fix') > -1
     };
-    this.spaSerializerClass = new Serializer(this);
+    this.spaSerializerClass = new Serializer(agentRef);
     const classThis = this;
     const baseEE = ee.get(agentRef.agentIdentifier); // <-- parent baseEE
     const mutationEE = baseEE.get('mutation');

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

@@ -2,7 +2,6 @@
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-
 import { initialLocation } from '../../../common/constants/runtime';
 import { gosNREUMOriginals } from '../../../common/window/nreum';
 import { InteractionNode } from './interaction-node';
@@ -80,7 +79,7 @@ InteractionPrototype.finish = function finishInteraction() {
   if (this.onFinished) {
     this.onFinished(this);
   }
-  Object.entries(interaction.agentRef.info?.jsAttributes || {}).forEach(([attr, value]) => {
+  Object.entries(interaction.agentRef.info.jsAttributes || {}).forEach(([attr, value]) => {
     if (!(attr in customAttrs)) customAttrs[attr] = value;
   });
   root.end = endTimestamp;

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

@@ -4,11 +4,10 @@
  */
 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/info';
-export class Serializer extends SharedContext {
-  constructor(parent) {
-    super(parent);
+export class Serializer {
+  constructor(agentRef) {
+    this.obfuscator = agentRef.runtime.obfuscator;
+    this.info = agentRef.info;
 
     /**
      * This variable is used to calculate an interactions ending offset when the
@@ -20,19 +19,17 @@ export class Serializer extends SharedContext {
     this.firstTimestamp = undefined;
   }
   serializeMultiple(interactions, offset, navTiming) {
-    const info = getInfo(this.sharedContext.agentIdentifier);
-    var addString = getAddStringContext(this.sharedContext.agentIdentifier);
+    var addString = getAddStringContext(this.obfuscator);
     var serialized = 'bel.7';
     interactions.forEach(interaction => {
-      serialized += ';' + this.serializeInteraction(interaction.root, offset, navTiming, interaction.routeChange, addString, info);
+      serialized += ';' + this.serializeInteraction(interaction.root, offset, navTiming, interaction.routeChange, addString, this.info);
     });
     this.firstTimestamp = undefined;
     return serialized;
   }
   serializeSingle(root, offset, navTiming, isRouteChange) {
-    const info = getInfo(this.sharedContext.agentIdentifier);
-    var addString = getAddStringContext(this.sharedContext.agentIdentifier);
-    var serialized = 'bel.7;' + this.serializeInteraction(root, offset, navTiming, isRouteChange, addString, info);
+    var addString = getAddStringContext(this.obfuscator);
+    var serialized = 'bel.7;' + this.serializeInteraction(root, offset, navTiming, isRouteChange, addString, this.info);
     this.firstTimestamp = undefined;
     return serialized;
   }

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

@@ -161,7 +161,7 @@ export class AggregateBase extends FeatureBase {
    */
   checkConfiguration(existingAgent) {
     // NOTE: This check has to happen at aggregator load time
-    if (!isValid(this.agentIdentifier)) {
+    if (!isValid(existingAgent.info)) {
       const cdn = gosCDN();
       let jsAttributes = {
         ...cdn.info?.jsAttributes

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

@@ -2,7 +2,6 @@
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getConfigurationValue } from '../../common/config/init';
 import { isBrowserScope } from '../../common/constants/runtime';
 
 /**
@@ -10,6 +9,6 @@ import { isBrowserScope } from '../../common/constants/runtime';
  * @param {string} agentId
  * @returns {boolean}
  */
-export const canEnableSessionTracking = agentId => {
-  return isBrowserScope && getConfigurationValue(agentId, 'privacy.cookies_enabled') === true;
+export const canEnableSessionTracking = agentInit => {
+  return isBrowserScope && agentInit?.privacy.cookies_enabled === true;
 };

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

@@ -81,7 +81,7 @@ export class InstrumentBase extends FeatureBase {
     const importLater = async () => {
       let session;
       try {
-        if (canEnableSessionTracking(this.agentIdentifier)) {
+        if (canEnableSessionTracking(agentRef.init)) {
           // would require some setup before certain features start
           const {
             setupAgentSession
@@ -99,7 +99,7 @@ export class InstrumentBase extends FeatureBase {
        * it's only responsible for aborting its one specific feature, rather than all.
        */
       try {
-        if (!this.#shouldImportAgg(this.featureName, session)) {
+        if (!this.#shouldImportAgg(this.featureName, session, agentRef.init)) {
           drain(this.agentIdentifier, this.featureName);
           loadedSuccessfully(false); // aggregate module isn't loaded at all
           return;
@@ -134,11 +134,11 @@ export class InstrumentBase extends FeatureBase {
   * @param {import('../../common/session/session-entity').SessionEntity} session
   * @returns
   */
-  #shouldImportAgg(featureName, session) {
+  #shouldImportAgg(featureName, session, agentInit) {
     switch (featureName) {
       case FEATURE_NAMES.sessionReplay:
         // the session manager must be initialized successfully for Replay & Trace features
-        return hasReplayPrerequisite(this.agentIdentifier) && !!session;
+        return hasReplayPrerequisite(agentInit) && !!session;
       case FEATURE_NAMES.sessionTrace:
         return !!session;
       default:

package/dist/esm/loaders/agent.js

@@ -73,7 +73,7 @@ export class Agent extends AgentBase {
   run() {
     // Attempt to initialize all the requested features (sequentially in prio order & synchronously), with any failure aborting the whole process.
     try {
-      const enabledFeatures = getEnabledFeatures(this.agentIdentifier);
+      const enabledFeatures = getEnabledFeatures(this.init);
       const featuresToStart = [...this.desiredFeatures];
       featuresToStart.sort((a, b) => featurePriority[a.featureName] - featurePriority[b.featureName]);
       featuresToStart.forEach(InstrumentCtor => {

package/dist/esm/loaders/api/api.js

@@ -118,17 +118,7 @@ export function setAPI(agent, forceDrain) {
    */
   function appendJsAttribute(key, value, apiName, addToBrowserStorage) {
     const currentInfo = agent.info;
-    if (value === null) {
-      delete currentInfo.jsAttributes[key];
-    } else {
-      agent.info = {
-        ...agent.info,
-        jsAttributes: {
-          ...currentInfo.jsAttributes,
-          [key]: value
-        }
-      };
-    }
+    if (value === null) delete currentInfo.jsAttributes[key];else currentInfo.jsAttributes[key] = value;
     return apiCall(prefix, apiName, true, !!addToBrowserStorage || value === null ? 'session' : undefined)(key, value);
   }
   agent.setCustomAttribute = function (name, value, persistAttribute = false) {

package/dist/esm/loaders/configure/configure.js

@@ -4,15 +4,15 @@
  */
 import { setAPI, setTopLevelCallers } from '../api/api';
 import { addToNREUM, gosCDN } from '../../common/window/nreum';
-import { setInfo } from '../../common/config/info';
-import { setConfiguration } from '../../common/config/init';
-import { setLoaderConfig } from '../../common/config/loader-config';
-import { setRuntime } from '../../common/config/runtime';
+import { mergeInfo } from '../../common/config/info';
+import { mergeInit } from '../../common/config/init';
+import { mergeRuntime } from '../../common/config/runtime';
 import { activatedFeatures } from '../../common/util/feature-flags';
 import { isWorkerScope } from '../../common/constants/runtime';
 import { redefinePublicPath } from './public-path';
 import { ee } from '../../common/event-emitter/contextual-ee';
 import { dispatchGlobalEvent } from '../../common/dispatch/global-event';
+import { mergeLoaderConfig } from '../../common/config/loader-config';
 const alreadySetOnce = new Set(); // the configure() function can run multiple times in agent lifecycle for different agents
 
 /**
@@ -28,23 +28,22 @@ export function configure(agent, opts = {}, loaderType, forceDrain) {
     runtime = {},
     exposed = true
   } = opts;
-  runtime.loaderType = loaderType;
-  const nr = gosCDN();
   if (!info) {
+    const nr = gosCDN();
     init = nr.init;
     info = nr.info;
     // eslint-disable-next-line camelcase
     loader_config = nr.loader_config;
   }
-  setConfiguration(agent.agentIdentifier, init || {});
+  agent.init = mergeInit(init || {});
   // eslint-disable-next-line camelcase
-  setLoaderConfig(agent.agentIdentifier, loader_config || {});
+  agent.loader_config = mergeLoaderConfig(loader_config || {});
   info.jsAttributes ??= {};
   if (isWorkerScope) {
     // add a default attr to all worker payloads
     info.jsAttributes.isWorker = true;
   }
-  setInfo(agent.agentIdentifier, info);
+  agent.info = mergeInfo(info);
   const updatedInit = agent.init;
   const internalTrafficList = [info.beacon, info.errorBeacon];
   if (!alreadySetOnce.has(agent.agentIdentifier)) {
@@ -61,7 +60,8 @@ export function configure(agent, opts = {}, loaderType, forceDrain) {
   }
   runtime.denyList = [...(updatedInit.ajax.deny_list || []), ...(updatedInit.ajax.block_internal ? internalTrafficList : [])];
   runtime.ptid = agent.agentIdentifier;
-  setRuntime(agent.agentIdentifier, runtime);
+  runtime.loaderType = loaderType;
+  agent.runtime = mergeRuntime(runtime);
   if (!alreadySetOnce.has(agent.agentIdentifier)) {
     agent.ee = ee.get(agent.agentIdentifier);
     agent.exposed = exposed;

package/dist/esm/loaders/features/enabled-features.js

@@ -3,15 +3,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { FEATURE_NAMES } from './features';
-import { getConfigurationValue } from '../../common/config/init';
 const featureNames = Object.values(FEATURE_NAMES);
-function isEnabled(name, agentIdentifier) {
-  return getConfigurationValue(agentIdentifier, "".concat(name, ".enabled")) === true;
-}
-export function getEnabledFeatures(agentIdentifier) {
+export function getEnabledFeatures(agentInit) {
   const enabledFeatures = {};
   featureNames.forEach(featureName => {
-    enabledFeatures[featureName] = isEnabled(featureName, agentIdentifier);
+    enabledFeatures[featureName] = !!agentInit[featureName]?.enabled;
   });
   return enabledFeatures;
 }

package/dist/esm/loaders/micro-agent.js

@@ -44,7 +44,7 @@ export class MicroAgent extends MicroAgentBase {
       try {
         if (featureNames === undefined || Array.isArray(featureNames) && featureNames.length === 0) featureNames = nonAutoFeatures;else if (typeof featureNames === 'string') featureNames = [featureNames];
         if (featureNames.some(f => !nonAutoFeatures.includes(f))) warn(37, nonAutoFeatures);
-        const enabledFeatures = getEnabledFeatures(this.agentIdentifier);
+        const enabledFeatures = getEnabledFeatures(this.init);
         try {
           // a biproduct of doing this is that the "session manager" is automatically handled through importing this feature
           this.features.page_view_event = new PVE(this);