@newrelic/browser-agent 1.285.0 → 1.286.0

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.285.0";
+export const VERSION = "1.286.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/dom/selector-path.js

@@ -40,7 +40,7 @@ export const generateSelectorPath = (elem, targetFields = []) => {
         localName
       } = elem;
       targetFields.forEach(field => {
-        nearestFields[nearestAttrName(field)] ||= elem[field];
+        nearestFields[nearestAttrName(field)] ||= elem[field]?.baseVal || elem[field];
       });
       const selector = [localName, id ? "#".concat(id) : '', pathSelector ? ">".concat(pathSelector) : ''].join('');
       pathSelector = selector;

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

@@ -210,7 +210,7 @@ function send(agentRef, {
   }
   dispatchGlobalEvent({
     agentIdentifier: agentRef.agentIdentifier,
-    loaded: !!activatedFeatures?.[agentRef.agentIdentifier],
+    drained: !!activatedFeatures?.[agentRef.agentIdentifier],
     type: 'data',
     name: 'harvest',
     feature: featureName,

package/dist/esm/common/util/feature-flags.js

@@ -25,10 +25,11 @@ export function activateFeatures(flags, agentIdentifier) {
   activatedFeatures[agentIdentifier] = flags;
   sentIds.add(agentIdentifier);
 
-  // let any window level subscribers know that the agent is running
+  // let any window level subscribers know that the agent is running, per install docs
   dispatchGlobalEvent({
     agentIdentifier,
     loaded: true,
+    drained: true,
     type: 'lifecycle',
     name: 'load',
     feature: undefined,

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

@@ -14,6 +14,8 @@ import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { buildNRMetaNode, customMasker } from './utils';
 import { IDEAL_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
 import { AggregateBase } from '../../utils/aggregate-base';
+import { warn } from '../../../common/util/console';
+import { single } from '../../../common/util/invoke';
 export class Recorder {
   /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
   #events;
@@ -23,6 +25,8 @@ export class Recorder {
   #preloaded;
   /** flag that if true, blocks events from being "stored".  Only set to true when a full snapshot has incomplete nodes (only stylesheets ATM) */
   #fixing = false;
+  #warnCSSOnce = single(() => warn(47)); // notifies user of potential replayer issue if fix_stylesheets is off
+
   constructor(parent) {
     this.#events = new RecorderEvents();
     this.#backloggedEvents = new RecorderEvents();
@@ -124,6 +128,7 @@ export class Recorder {
     if (!this.shouldFix) {
       if (incompletes > 0) {
         this.currentBufferTarget.inlinedAllStylesheets = false;
+        this.#warnCSSOnce();
         handle(SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Skipped', incompletes], undefined, FEATURE_NAMES.metrics, this.parent.ee);
       }
       return this.store(event, isCheckout);

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

@@ -15,7 +15,8 @@ const ignoredEvents = {
   // we find that certain events make the data too noisy to be useful
   global: {
     mouseup: true,
-    mousedown: true
+    mousedown: true,
+    mousemove: true
   },
   // certain events are present both in the window and in PVT metrics.  PVT metrics are prefered so the window events should be ignored
   window: {
@@ -177,8 +178,8 @@ export class TraceStorage {
     this.storeSTN(evt);
   }
   shouldIgnoreEvent(event, target) {
-    const origin = eventOrigin(event.target, target, this.parent.ee);
     if (event.type in ignoredEvents.global) return true;
+    const origin = eventOrigin(event.target, target, this.parent.ee);
     if (!!ignoredEvents[origin] && ignoredEvents[origin].ignoreAll) return true;
     return !!(!!ignoredEvents[origin] && event.type in ignoredEvents[origin]);
   }

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

@@ -138,16 +138,14 @@ export class AggregateBase extends FeatureBase {
       } catch (err) {
         // do nothing
       }
-      configure({
-        agentIdentifier: this.agentIdentifier
-      }, {
+      configure(existingAgent, {
         ...cdn,
         info: {
           ...cdn.info,
           jsAttributes
         },
         runtime: existingAgent.runtime
-      });
+      }, existingAgent.runtime.loaderType);
     }
   }
 

package/dist/esm/features/utils/event-store-manager.js

@@ -52,7 +52,7 @@ export class EventStoreManager {
   add(event, target) {
     dispatchGlobalEvent({
       agentIdentifier: this.agentIdentifier,
-      loaded: !!activatedFeatures?.[this.agentIdentifier],
+      drained: !!activatedFeatures?.[this.agentIdentifier],
       type: 'data',
       name: 'buffer',
       feature: this.featureName,

package/dist/esm/features/utils/nr1-debugger.js

@@ -6,7 +6,7 @@ import { gosCDN } from '../../common/window/nreum';
 const debugId = 1;
 const newrelic = gosCDN();
 export function debugNR1(agentIdentifier, location, event, otherprops = {}, debugName = 'SR') {
-  const api = agentIdentifier ? newrelic.initializedAgents[agentIdentifier].api.addPageAction : newrelic.addPageAction;
+  const api = agentIdentifier ? newrelic.initializedAgents[agentIdentifier].addPageAction : newrelic.addPageAction;
   let url;
   try {
     const locURL = new URL(window.location);

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

@@ -20,7 +20,7 @@ export class AgentBase extends MicroAgentBase {
    * @param  {...any} args
    */
   #callMethod(methodName, ...args) {
-    if (typeof this.api?.[methodName] !== 'function') warn(35, methodName);else return this.api[methodName](...args);
+    if (this[methodName] === AgentBase.prototype[methodName] || this[methodName] === MicroAgentBase.prototype[methodName]) warn(35, methodName);else return this[methodName](...args);
   }
 
   /**

package/dist/esm/loaders/agent.js

@@ -67,6 +67,9 @@ export class Agent extends AgentBase {
       runtime: this.runtime
     };
   }
+  get api() {
+    return this;
+  }
   run() {
     // Attempt to initialize all the requested features (sequentially in prio order & synchronously), with any failure aborting the whole process.
     try {
@@ -94,7 +97,6 @@ export class Agent extends AgentBase {
         this.features[featName].abortHandler?.();
       }
       const newrelic = gosNREUM();
-      delete newrelic.initializedAgents[this.agentIdentifier]?.api; // prevent further calls to agent-specific APIs (see "configure.js")
       delete newrelic.initializedAgents[this.agentIdentifier]?.features; // GC mem used internally by features
       delete this.sharedAggregator;
       // Keep the initialized agent object with its configs for troubleshooting purposes.

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

@@ -3,10 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { FEATURE_NAMES } from '../features/features';
-import { getInfo, setInfo } from '../../common/config/info';
-import { getRuntime } from '../../common/config/runtime';
+import { setInfo } from '../../common/config/info';
 import { handle } from '../../common/event-emitter/handle';
-import { ee } from '../../common/event-emitter/contextual-ee';
 import { drain, registerDrain } from '../../common/drain/drain';
 import { onWindowLoad } from '../../common/window/load';
 import { isBrowserScope } from '../../common/constants/runtime';
@@ -29,41 +27,39 @@ export function setTopLevelCallers() {
   });
   function caller(fnName, ...args) {
     let returnVals = [];
-    Object.values(nr.initializedAgents).forEach(val => {
-      if (!val || !val.api) {
+    Object.values(nr.initializedAgents).forEach(agt => {
+      if (!agt || !agt.runtime) {
         warn(38, fnName);
-      } else if (val.exposed && val.api[fnName]) {
-        returnVals.push(val.api[fnName](...args));
+      } else if (agt.exposed && agt[fnName] && agt.runtime.loaderType !== 'micro-agent') {
+        returnVals.push(agt[fnName](...args));
       }
     });
-    return returnVals.length > 1 ? returnVals : returnVals[0];
+    return returnVals[0];
   }
 }
 const replayRunning = {};
-export function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
-  if (!forceDrain) registerDrain(agentIdentifier, 'api');
-  const apiInterface = {};
-  var instanceEE = ee.get(agentIdentifier);
-  var tracerEE = instanceEE.get('tracer');
-  replayRunning[agentIdentifier] = MODE.OFF;
-  instanceEE.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
-    replayRunning[agentIdentifier] = isRunning;
+export function setAPI(agent, forceDrain) {
+  if (!forceDrain) registerDrain(agent.agentIdentifier, 'api');
+  const tracerEE = agent.ee.get('tracer');
+  replayRunning[agent.agentIdentifier] = MODE.OFF;
+  agent.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
+    replayRunning[agent.agentIdentifier] = isRunning;
   });
-  var prefix = 'api-';
-  var spaPrefix = prefix + 'ixn-';
-  apiInterface.log = function (message, {
+  const prefix = 'api-';
+  const spaPrefix = prefix + 'ixn-';
+  agent.log = function (message, {
     customAttributes = {},
     level = LOG_LEVELS.INFO
   } = {}) {
-    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/log/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-    bufferLog(instanceEE, message, customAttributes, level);
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/log/called'], undefined, FEATURE_NAMES.metrics, agent.ee);
+    bufferLog(agent.ee, message, customAttributes, level);
   };
-  apiInterface.wrapLogger = (parent, functionName, {
+  agent.wrapLogger = (parent, functionName, {
     customAttributes = {},
     level = LOG_LEVELS.INFO
   } = {}) => {
-    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/wrapLogger/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-    wrapLogger(instanceEE, parent, functionName, {
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/wrapLogger/called'], undefined, FEATURE_NAMES.metrics, agent.ee);
+    wrapLogger(agent.ee, parent, functionName, {
       customAttributes,
       level
     });
@@ -71,14 +67,14 @@ export function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
 
   // Setup stub functions that queue calls for later processing.
   asyncApiMethods.forEach(fnName => {
-    apiInterface[fnName] = apiCall(prefix, fnName, true, 'api');
+    agent[fnName] = apiCall(prefix, fnName, true, 'api');
   });
-  apiInterface.addPageAction = apiCall(prefix, 'addPageAction', true, FEATURE_NAMES.genericEvents);
-  apiInterface.recordCustomEvent = apiCall(prefix, 'recordCustomEvent', true, FEATURE_NAMES.genericEvents);
-  apiInterface.setPageViewName = function (name, host) {
+  agent.addPageAction = apiCall(prefix, 'addPageAction', true, FEATURE_NAMES.genericEvents);
+  agent.recordCustomEvent = apiCall(prefix, 'recordCustomEvent', true, FEATURE_NAMES.genericEvents);
+  agent.setPageViewName = function (name, host) {
     if (typeof name !== 'string') return;
     if (name.charAt(0) !== '/') name = '/' + name;
-    getRuntime(agentIdentifier).customTransaction = (host || 'http://custom.transaction') + name;
+    agent.runtime.customTransaction = (host || 'http://custom.transaction') + name;
     return apiCall(prefix, 'setPageViewName', true)();
   };
 
@@ -91,11 +87,11 @@ export function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
    * @returns @see apiCall
    */
   function appendJsAttribute(key, value, apiName, addToBrowserStorage) {
-    const currentInfo = getInfo(agentIdentifier);
+    const currentInfo = agent.info;
     if (value === null) {
       delete currentInfo.jsAttributes[key];
     } else {
-      setInfo(agentIdentifier, {
+      setInfo(agent.agentIdentifier, {
         ...currentInfo,
         jsAttributes: {
           ...currentInfo.jsAttributes,
@@ -105,7 +101,7 @@ export function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
     }
     return apiCall(prefix, apiName, true, !!addToBrowserStorage || value === null ? 'session' : undefined)(key, value);
   }
-  apiInterface.setCustomAttribute = function (name, value, persistAttribute = false) {
+  agent.setCustomAttribute = function (name, value, persistAttribute = false) {
     if (typeof name !== 'string') {
       warn(39, typeof name);
       return;
@@ -121,7 +117,7 @@ export function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
    * @param {string} value - unique user identifier; a null user id suggests none should exist
    * @returns @see apiCall
    */
-  apiInterface.setUserId = function (value) {
+  agent.setUserId = function (value) {
     if (!(typeof value === 'string' || value === null)) {
       warn(41, typeof value);
       return;
@@ -134,30 +130,30 @@ export function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
    * @param {string|null} value - Application version -- if null, will "unset" the value
    * @returns @see apiCall
    */
-  apiInterface.setApplicationVersion = function (value) {
+  agent.setApplicationVersion = function (value) {
     if (!(typeof value === 'string' || value === null)) {
       warn(42, typeof value);
       return;
     }
     return appendJsAttribute('application.version', value, 'setApplicationVersion', false);
   };
-  apiInterface.start = () => {
+  agent.start = () => {
     try {
-      handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/start/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-      instanceEE.emit('manual-start-all');
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/start/called'], undefined, FEATURE_NAMES.metrics, agent.ee);
+      agent.ee.emit('manual-start-all');
     } catch (err) {
       warn(23, err);
     }
   };
-  apiInterface[SR_EVENT_EMITTER_TYPES.RECORD] = function () {
-    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/recordReplay/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-    handle(SR_EVENT_EMITTER_TYPES.RECORD, [], undefined, FEATURE_NAMES.sessionReplay, instanceEE);
+  agent[SR_EVENT_EMITTER_TYPES.RECORD] = function () {
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/recordReplay/called'], undefined, FEATURE_NAMES.metrics, agent.ee);
+    handle(SR_EVENT_EMITTER_TYPES.RECORD, [], undefined, FEATURE_NAMES.sessionReplay, agent.ee);
   };
-  apiInterface[SR_EVENT_EMITTER_TYPES.PAUSE] = function () {
-    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/pauseReplay/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-    handle(SR_EVENT_EMITTER_TYPES.PAUSE, [], undefined, FEATURE_NAMES.sessionReplay, instanceEE);
+  agent[SR_EVENT_EMITTER_TYPES.PAUSE] = function () {
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/pauseReplay/called'], undefined, FEATURE_NAMES.metrics, agent.ee);
+    handle(SR_EVENT_EMITTER_TYPES.PAUSE, [], undefined, FEATURE_NAMES.sessionReplay, agent.ee);
   };
-  apiInterface.interaction = function (options) {
+  agent.interaction = function (options) {
     return new InteractionHandle().get(typeof options === 'object' ? options : {});
   };
   function InteractionHandle() {}
@@ -166,9 +162,9 @@ export function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
       var contextStore = {};
       var ixn = this;
       var hasCb = typeof cb === 'function';
-      handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/createTracer/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/createTracer/called'], undefined, FEATURE_NAMES.metrics, agent.ee);
       // Soft navigations won't support Tracer nodes, but this fn should still work the same otherwise (e.g., run the orig cb).
-      if (!runSoftNavOverSpa) handle(spaPrefix + 'tracer', [now(), name, contextStore], ixn, FEATURE_NAMES.spa, instanceEE);
+      if (!agent.runSoftNavOverSpa) handle(spaPrefix + 'tracer', [now(), name, contextStore], ixn, FEATURE_NAMES.spa, agent.ee);
       return function () {
         tracerEE.emit((hasCb ? '' : 'no-') + 'fn-start', [now(), ixn, hasCb], contextStore);
         if (hasCb) {
@@ -187,15 +183,15 @@ export function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
     }
   };
   ['actionText', 'setName', 'setAttribute', 'save', 'ignore', 'onEnd', 'getContext', 'end', 'get'].forEach(name => {
-    InteractionApiProto[name] = apiCall(spaPrefix, name, undefined, runSoftNavOverSpa ? FEATURE_NAMES.softNav : FEATURE_NAMES.spa);
+    InteractionApiProto[name] = apiCall(spaPrefix, name, undefined, agent.runSoftNavOverSpa ? FEATURE_NAMES.softNav : FEATURE_NAMES.spa);
   });
-  apiInterface.setCurrentRouteName = runSoftNavOverSpa ? apiCall(spaPrefix, 'routeName', undefined, FEATURE_NAMES.softNav) : apiCall(prefix, 'routeName', true, FEATURE_NAMES.spa);
+  agent.setCurrentRouteName = agent.runSoftNavOverSpa ? apiCall(spaPrefix, 'routeName', undefined, FEATURE_NAMES.softNav) : apiCall(prefix, 'routeName', true, FEATURE_NAMES.spa);
   function apiCall(prefix, name, notSpa, bufferGroup) {
     return function () {
-      handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/' + name + '/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/' + name + '/called'], undefined, FEATURE_NAMES.metrics, agent.ee);
       dispatchGlobalEvent({
-        agentIdentifier,
-        loaded: !!activatedFeatures?.[agentIdentifier],
+        agentIdentifier: agent.agentIdentifier,
+        drained: !!activatedFeatures?.[agent.agentIdentifier],
         type: 'data',
         name: 'api',
         feature: prefix + name,
@@ -204,14 +200,14 @@ export function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
           bufferGroup
         }
       });
-      if (bufferGroup) handle(prefix + name, [notSpa ? now() : performance.now(), ...arguments], notSpa ? null : this, bufferGroup, instanceEE); // no bufferGroup means only the SM is emitted
+      if (bufferGroup) handle(prefix + name, [notSpa ? now() : performance.now(), ...arguments], notSpa ? null : this, bufferGroup, agent.ee); // no bufferGroup means only the SM is emitted
       return notSpa ? undefined : this; // returns the InteractionHandle which allows these methods to be chained
     };
   }
-  apiInterface.noticeError = function (err, customAttributes) {
+  agent.noticeError = function (err, customAttributes) {
     if (typeof err === 'string') err = new Error(err);
-    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/noticeError/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-    handle('err', [err, now(), false, customAttributes, !!replayRunning[agentIdentifier]], undefined, FEATURE_NAMES.jserrors, instanceEE);
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/noticeError/called'], undefined, FEATURE_NAMES.metrics, agent.ee);
+    handle('err', [err, now(), false, customAttributes, !!replayRunning[agent.agentIdentifier]], undefined, FEATURE_NAMES.jserrors, agent.ee);
   };
 
   // theres no window.load event on non-browser scopes, lazy load immediately
@@ -220,14 +216,14 @@ export function setAPI(agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
   else onWindowLoad(() => lazyLoad(), true);
   function lazyLoad() {
     import(/* webpackChunkName: "async-api" */'./apiAsync').then(({
-      setAPI
+      setAsyncAPI
     }) => {
-      setAPI(agentIdentifier);
-      drain(agentIdentifier, 'api');
+      setAsyncAPI(agent);
+      drain(agent.agentIdentifier, 'api');
     }).catch(err => {
       warn(27, err);
-      instanceEE.abort();
+      agent.ee.abort();
     });
   }
-  return apiInterface;
+  return true;
 }

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

@@ -3,16 +3,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { FEATURE_NAMES } from '../features/features';
-import { getRuntime } from '../../common/config/runtime';
-import { ee } from '../../common/event-emitter/contextual-ee';
 import { handle } from '../../common/event-emitter/handle';
 import { registerHandler } from '../../common/event-emitter/register-handler';
 import { single } from '../../common/util/invoke';
 import { CUSTOM_METRIC_CHANNEL } from '../../features/metrics/constants';
 import { originTime } from '../../common/constants/runtime';
-export function setAPI(agentIdentifier) {
-  var instanceEE = ee.get(agentIdentifier);
-  var api = {
+export function setAsyncAPI(agent) {
+  const api = {
     finished: single(finished),
     setErrorHandler,
     addToTrace,
@@ -20,40 +17,40 @@ export function setAPI(agentIdentifier) {
   };
 
   // Hook all of the api functions up to the queues/stubs created in loader/api.js
-  Object.entries(api).forEach(([fnName, fnCall]) => registerHandler('api-' + fnName, fnCall, 'api', instanceEE));
+  Object.entries(api).forEach(([fnName, fnCall]) => registerHandler('api-' + fnName, fnCall, 'api', agent.ee));
 
   // All API functions get passed the time they were called as their
   // first parameter. These functions can be called asynchronously.
 
   function finished(t, providedTime) {
-    var time = providedTime ? providedTime - originTime : t;
+    const time = providedTime ? providedTime - originTime : t;
     handle(CUSTOM_METRIC_CHANNEL, ['finished', {
       time
-    }], undefined, FEATURE_NAMES.metrics, instanceEE);
+    }], undefined, FEATURE_NAMES.metrics, agent.ee);
     addToTrace(t, {
       name: 'finished',
       start: time + originTime,
       origin: 'nr'
     });
-    handle('api-addPageAction', [time, 'finished'], undefined, FEATURE_NAMES.genericEvents, instanceEE);
+    handle('api-addPageAction', [time, 'finished'], undefined, FEATURE_NAMES.genericEvents, agent.ee);
   }
-  function addToTrace(t, evt) {
+  function addToTrace(_, evt) {
     if (!(evt && typeof evt === 'object' && evt.name && evt.start)) return;
-    var report = {
+    const report = {
       n: evt.name,
       s: evt.start - originTime,
       e: (evt.end || evt.start) - originTime,
       o: evt.origin || '',
       t: 'api'
     };
-    handle('bstApi', [report], undefined, FEATURE_NAMES.sessionTrace, instanceEE);
+    handle('bstApi', [report], undefined, FEATURE_NAMES.sessionTrace, agent.ee);
   }
-  function setErrorHandler(t, handler) {
-    getRuntime(agentIdentifier).onerror = handler;
+  function setErrorHandler(_, handler) {
+    agent.runtime.onerror = handler;
   }
-  var releaseCount = 0;
-  function addRelease(t, name, id) {
+  let releaseCount = 0;
+  function addRelease(_, name, id) {
     if (++releaseCount > 10) return;
-    getRuntime(agentIdentifier).releaseIds[name.slice(-200)] = ('' + id).slice(-200);
+    agent.runtime.releaseIds[name.slice(-200)] = ('' + id).slice(-200);
   }
 }

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

@@ -5,7 +5,7 @@
 import { setAPI, setTopLevelCallers } from '../api/api';
 import { addToNREUM, gosCDN } from '../../common/window/nreum';
 import { setInfo } from '../../common/config/info';
-import { getConfiguration, setConfiguration } from '../../common/config/init';
+import { setConfiguration } from '../../common/config/init';
 import { setLoaderConfig } from '../../common/config/loader-config';
 import { setRuntime } from '../../common/config/runtime';
 import { activatedFeatures } from '../../common/util/feature-flags';
@@ -13,10 +13,11 @@ 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';
-let alreadySetOnce = false; // the configure() function can run multiple times in agent lifecycle
+const alreadySetOnce = new Set(); // the configure() function can run multiple times in agent lifecycle for different agents
 
 /**
  * Sets or re-sets the agent's configuration values from global settings. This also attach those as properties to the agent instance.
+ * IMPORTANT: setNREUMInitializedAgent must be called on the agent prior to calling this function.
  */
 export function configure(agent, opts = {}, loaderType, forceDrain) {
   // eslint-disable-next-line camelcase
@@ -44,9 +45,9 @@ export function configure(agent, opts = {}, loaderType, forceDrain) {
     info.jsAttributes.isWorker = true;
   }
   setInfo(agent.agentIdentifier, info);
-  const updatedInit = getConfiguration(agent.agentIdentifier);
+  const updatedInit = agent.init;
   const internalTrafficList = [info.beacon, info.errorBeacon];
-  if (!alreadySetOnce) {
+  if (!alreadySetOnce.has(agent.agentIdentifier)) {
     if (updatedInit.proxy.assets) {
       redefinePublicPath(updatedInit.proxy.assets);
       internalTrafficList.push(updatedInit.proxy.assets);
@@ -61,23 +62,19 @@ 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);
-  agent.ee = ee.get(agent.agentIdentifier);
-  if (agent.api === undefined) agent.api = setAPI(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa);
-  if (agent.exposed === undefined) agent.exposed = exposed;
-  if (!alreadySetOnce) {
+  if (!alreadySetOnce.has(agent.agentIdentifier)) {
+    agent.ee = ee.get(agent.agentIdentifier);
+    agent.exposed = exposed;
+    setAPI(agent, forceDrain); // assign our API functions to the agent instance
+
     dispatchGlobalEvent({
       agentIdentifier: agent.agentIdentifier,
-      loaded: !!activatedFeatures?.[agent.agentIdentifier],
+      drained: !!activatedFeatures?.[agent.agentIdentifier],
       type: 'lifecycle',
       name: 'initialize',
       feature: undefined,
-      data: {
-        init: updatedInit,
-        info,
-        loader_config,
-        runtime
-      }
+      data: agent.config
     });
   }
-  alreadySetOnce = true;
+  alreadySetOnce.add(agent.agentIdentifier);
 }

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

@@ -16,7 +16,7 @@ export class MicroAgentBase {
    * @param  {...any} args
    */
   #callMethod(methodName, ...args) {
-    if (typeof this.api?.[methodName] !== 'function') warn(35, methodName);else return this.api[methodName](...args);
+    if (this[methodName] === MicroAgentBase.prototype[methodName]) warn(35, methodName);else return this[methodName](...args);
   }
 
   // MicroAgent class custom defines its own start

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

@@ -33,7 +33,6 @@ export class MicroAgent extends MicroAgentBase {
         isolatedBacklog: true
       }
     }, options.loaderType || 'micro-agent');
-    Object.assign(this, this.api); // the APIs should be available at the class level for micro-agent
 
     /**
      * Starts a set of agent features if not running in "autoStart" mode
@@ -86,4 +85,7 @@ export class MicroAgent extends MicroAgentBase {
       runtime: this.runtime
     };
   }
+  get api() {
+    return this;
+  }
 }

package/dist/types/common/dom/selector-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selector-path.d.ts","sourceRoot":"","sources":["../../../../src/common/dom/selector-path.js"],"names":[],"mappings":"AAYO,2CALI,WAAW,yBAGT,MAAM,GAAC,SAAS,CAmD5B"}
+{"version":3,"file":"selector-path.d.ts","sourceRoot":"","sources":["../../../../src/common/dom/selector-path.js"],"names":[],"mappings":"AAYO,2CALI,WAAW,yBAGT,MAAM,GAAC,SAAS,CAiD5B"}

package/dist/types/common/util/feature-flags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../../../src/common/util/feature-flags.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,wCAJW;IAAC,CAAC,GAAG,EAAC,MAAM,GAAE,MAAM,CAAA;CAAC,mBACrB,MAAM,GACJ,IAAI,CAsBhB;AA9BD,gGAAgG;AAChG,mCAAmC"}
+{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../../../src/common/util/feature-flags.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,wCAJW;IAAC,CAAC,GAAG,EAAC,MAAM,GAAE,MAAM,CAAA;CAAC,mBACrB,MAAM,GACJ,IAAI,CAuBhB;AA/BD,gGAAgG;AAChG,mCAAmC"}

package/dist/types/features/session_replay/shared/recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAiBA;IAUE,yBAkBC;IAdC,iEAAiE;IACjE,mBAAsB;IACtB,6DAA6D;IAC7D,oCAAuC;IACvC,+IAA+I;IAC/I,yBAA4B;IAC5B,kIAAkI;IAClI,kBAAqB;IACrB,sDAAsD;IACtD,YAAoB;IACpB,0FAA0F;IAC1F,eAAyE;IACzE,uIAAuI;IACvI,0BAAyE;IAG3E;;;;;;;;;MAmBC;IAED,mFAAmF;IACnF,oBAKC;IAED,qDAAqD;IACrD,uBA6BC;IAED;;;;;OAKG;IACH,aAHW,GAAC,cACD,GAAC,QAgCX;IAED,0HAA0H;IAC1H,yCAoDC;IA1CG,8BAAoB;IA4CxB,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BA9N8B,mBAAmB"}
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAmBA;IAYE,yBAkBC;IAdC,iEAAiE;IACjE,mBAAsB;IACtB,6DAA6D;IAC7D,oCAAuC;IACvC,+IAA+I;IAC/I,yBAA4B;IAC5B,kIAAkI;IAClI,kBAAqB;IACrB,sDAAsD;IACtD,YAAoB;IACpB,0FAA0F;IAC1F,eAAyE;IACzE,uIAAuI;IACvI,0BAAyE;IAG3E;;;;;;;;;MAmBC;IAED,mFAAmF;IACnF,oBAKC;IAED,qDAAqD;IACrD,uBA6BC;IAED;;;;;OAKG;IACH,aAHW,GAAC,cACD,GAAC,QAiCX;IAED,0HAA0H;IAC1H,yCAoDC;IA1CG,8BAAoB;IA4CxB,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BAnO8B,mBAAmB"}

package/dist/types/loaders/agent.d.ts

@@ -26,6 +26,7 @@ export class Agent extends AgentBase {
         loader_config: any;
         runtime: any;
     };
+    get api(): this;
     run(): false | undefined;
 }
 export type AgentOptions = {

package/dist/types/loaders/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/agent.js"],"names":[],"mappings":"AAqBA;;;;;;;;;GASG;AAEH;;;GAGG;AACH;IACE;;OAEG;IACH,qBAFW,YAAY,EAyBtB;IAbC,yBAAkB;IAGlB,yCAAsD;IAMtD,uCAA6G;IAM/G;;;;;MAOC;IAED,yBAsCC;CACF;;;;;UA1Fa,OAAO,uBAAuB,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;0BAdxB,cAAc"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/agent.js"],"names":[],"mappings":"AAqBA;;;;;;;;;GASG;AAEH;;;GAGG;AACH;IACE;;OAEG;IACH,qBAFW,YAAY,EAyBtB;IAbC,yBAAkB;IAGlB,yCAAsD;IAMtD,uCAA6G;IAM/G;;;;;MAOC;IAED,gBAEC;IAED,yBAqCC;CACF;;;;;UA7Fa,OAAO,uBAAuB,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;0BAdxB,cAAc"}

package/dist/types/loaders/api/api.d.ts

@@ -1,22 +1,3 @@
 export function setTopLevelCallers(): void;
-export function setAPI(agentIdentifier: any, forceDrain: any, runSoftNavOverSpa?: boolean): {
-    log(message: any, { customAttributes, level }?: {
-        customAttributes?: {} | undefined;
-        level?: string | undefined;
-    }): void;
-    wrapLogger(parent: any, functionName: any, { customAttributes, level }?: {
-        customAttributes?: {} | undefined;
-        level?: string | undefined;
-    }): void;
-    addPageAction: (...args: any[]) => any;
-    recordCustomEvent: (...args: any[]) => any;
-    setPageViewName(name: any, host: any): any;
-    setCustomAttribute(name: any, value: any, persistAttribute?: boolean): any;
-    setUserId(value: string): any;
-    setApplicationVersion(value: string | null): any;
-    start(): void;
-    interaction(options: any): any;
-    setCurrentRouteName: (...args: any[]) => any;
-    noticeError(err: any, customAttributes: any): void;
-};
+export function setAPI(agent: any, forceDrain: any): boolean;
 //# sourceMappingURL=api.d.ts.map

package/dist/types/loaders/api/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/api.js"],"names":[],"mappings":"AAyBA,2CAiBC;AAID;;;;;;;;;;;;;qBAqEa,MAAM;iCAaN,MAAM,GAAC,IAAI;;;;;EAyGvB"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/api.js"],"names":[],"mappings":"AAuBA,2CAiBC;AAID,6DAyLC"}

package/dist/types/loaders/api/apiAsync.d.ts

@@ -1,2 +1,2 @@
-export function setAPI(agentIdentifier: any): void;
+export function setAsyncAPI(agent: any): void;
 //# sourceMappingURL=apiAsync.d.ts.map

package/dist/types/loaders/api/apiAsync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apiAsync.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/apiAsync.js"],"names":[],"mappings":"AAaA,mDA8CC"}
+{"version":3,"file":"apiAsync.d.ts","sourceRoot":"","sources":["../../../../src/loaders/api/apiAsync.js"],"names":[],"mappings":"AAWA,8CA4CC"}