@newrelic/browser-agent 1.286.0 → 1.287.0

package/dist/cjs/features/logging/shared/utils.js

@@ -20,10 +20,11 @@ var _constants2 = require("../constants");
    * @param {string} message - the log message string
    * @param {{[key: string]: *}} customAttributes - The log's custom attributes if any
    * @param {enum} level - the log level enum
+   * @param {object=} targetEntityGuid - the optional target entity guid provided by an api call
    */
-function bufferLog(ee, message, customAttributes = {}, level = _constants2.LOG_LEVELS.INFO) {
+function bufferLog(ee, message, customAttributes = {}, level = _constants2.LOG_LEVELS.INFO, targetEntityGuid, timestamp = (0, _now.now)()) {
   (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ["API/logging/".concat(level.toLowerCase(), "/called")], undefined, _features.FEATURE_NAMES.metrics, ee);
-  (0, _handle.handle)(_constants2.LOGGING_EVENT_EMITTER_CHANNEL, [(0, _now.now)(), message, customAttributes, level], undefined, _features.FEATURE_NAMES.logging, ee);
+  (0, _handle.handle)(_constants2.LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, targetEntityGuid], undefined, _features.FEATURE_NAMES.logging, ee);
 }
 
 /**

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

@@ -28,8 +28,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.harvestOpts.aggregatorTypes = ['cm', 'sm']; // the types in EventAggregator this feature cares about
     // This feature only harvests once per potential EoL of the page, which is handled by the central harvester.
 
+    // this must be read/stored synchronously, as the currentScript is removed from the DOM after this script is executed and this lookup will be void
+    // its used to report a SM later in the lifecycle
+    this.agentNonce = _runtime.isBrowserScope && document.currentScript?.nonce;
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
+        this.singleChecks(); // checks that are run only one time, at script load
+        this.eachSessionChecks(); // the start of every time user engages with page
         this.drain();
       } else {
         this.blocked = true; // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
@@ -40,8 +45,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     // Allow features external to the metrics feature to capture SMs and CMs through the event emitter
     (0, _registerHandler.registerHandler)(_constants.SUPPORTABILITY_METRIC_CHANNEL, this.storeSupportabilityMetrics.bind(this), this.featureName, this.ee);
     (0, _registerHandler.registerHandler)(_constants.CUSTOM_METRIC_CHANNEL, this.storeEventMetrics.bind(this), this.featureName, this.ee);
-    this.singleChecks(); // checks that are run only one time, at script load
-    this.eachSessionChecks(); // the start of every time user engages with page
   }
   preHarvestChecks(opts) {
     return this.drained && opts.isFinalHarvest;
@@ -77,8 +80,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (distMethod) this.storeSupportabilityMetrics("Generic/DistMethod/".concat(distMethod, "/Detected"));
     if (_runtime.isBrowserScope) {
       this.storeSupportabilityMetrics('Generic/Runtime/Browser/Detected');
-      const nonce = document?.currentScript?.nonce;
-      if (nonce && nonce !== '') {
+      if (this.agentNonce && this.agentNonce !== '') {
         this.storeSupportabilityMetrics('Generic/Runtime/Nonce/Detected');
       }
 

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

@@ -19,6 +19,8 @@ var _timeToFirstByte = require("../../../common/vitals/time-to-first-byte");
 var _now = require("../../../common/timing/now");
 var _timeKeeper = require("../../../common/timing/time-keeper");
 var _traverse = require("../../../common/util/traverse");
+var _registerHandler = require("../../../common/event-emitter/register-handler");
+var _target = require("../../../common/util/target");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /**
@@ -34,6 +36,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.firstByteToWindowLoad = 0; // our "frontend" duration
     this.firstByteToDomContent = 0; // our "dom processing" duration
 
+    (0, _registerHandler.registerHandler)('send-rum', (customAttibutes, target) => {
+      this.sendRum(customAttibutes, target);
+    }, this.featureName, this.ee);
     if (!(0, _info.isValid)(agentRef.agentIdentifier)) {
       this.ee.abort();
       return (0, _console.warn)(43);
@@ -56,7 +61,17 @@ class Aggregate extends _aggregateBase.AggregateBase {
       this.sendRum();
     }
   }
-  sendRum() {
+
+  /**
+   *
+   * @param {Function} cb A function to run once the RUM call has finished - Defaults to activateFeatures
+   * @param {*} customAttributes custom attributes to attach to the RUM call - Defaults to info.js
+   * @param {*} target The target to harvest to - Since we will not know the entityGuid before harvesting, this must be an object directly supplied from the info object or API, not an entityGuid string for lookup with the entityManager - Defaults to { licenseKey: this.agentRef.info.licenseKey, applicationID: this.agentRef.info.applicationID }
+   */
+  sendRum(customAttributes = this.agentRef.info.jsAttributes, target = {
+    licenseKey: this.agentRef.info.licenseKey,
+    applicationID: this.agentRef.info.applicationID
+  }) {
     const info = this.agentRef.info;
     const measures = {};
     if (info.queueTime) measures.qt = info.queueTime;
@@ -82,9 +97,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (this.agentRef.runtime.session) queryParameters.fsh = Number(this.agentRef.runtime.session.isNew); // "first session harvest" aka RUM request or PageView event of a session
 
     let body;
-    if (typeof info.jsAttributes === 'object' && Object.keys(info.jsAttributes).length > 0) {
+    if (typeof customAttributes === 'object' && Object.keys(customAttributes).length > 0) {
       body = (0, _traverse.applyFnToProps)({
-        ja: info.jsAttributes
+        ja: customAttributes
       }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string');
     }
     if (_runtime.globalScope.performance) {
@@ -114,7 +129,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.rumStartTime = (0, _now.now)();
     this.agentRef.runtime.harvester.triggerHarvestFor(this, {
       directSend: {
-        targetApp: this.agentRef.mainAppKey,
+        targetApp: target,
         payload: {
           qs: queryParameters,
           body
@@ -127,20 +142,32 @@ class Aggregate extends _aggregateBase.AggregateBase {
   postHarvestCleanup({
     status,
     responseText,
-    xhr
+    xhr,
+    targetApp
   }) {
     const rumEndTime = (0, _now.now)();
+    let app, flags;
+    try {
+      ({
+        app,
+        ...flags
+      } = JSON.parse(responseText));
+      this.processEntities(app.agents, targetApp);
+    } catch (error) {
+      // wont set entity stuff here, if main agent will later abort, if registered agent, nothing will happen
+      (0, _console.warn)(53, error);
+    }
+
+    /** Only run agent-wide side-effects if the harvest was for the main agent */
+    if (!(0, _target.isContainerAgentTarget)(targetApp, this.agentRef)) return;
     if (status >= 400 || status === 0) {
       (0, _console.warn)(18, status);
       // Adding retry logic for the rum call will be a separate change; this.blocked will need to be changed since that prevents another triggerHarvestFor()
       this.ee.abort();
       return;
     }
-    const {
-      app,
-      ...flags
-    } = JSON.parse(responseText);
     try {
+      // will do nothing if already done
       this.agentRef.runtime.timeKeeper.processRumRequest(xhr, this.rumStartTime, rumEndTime, app.nrServerTime);
       if (!this.agentRef.runtime.timeKeeper.ready) throw new Error('TimeKeeper not ready');
     } catch (error) {
@@ -148,10 +175,32 @@ class Aggregate extends _aggregateBase.AggregateBase {
       (0, _console.warn)(17, error);
       return;
     }
-    this.agentRef.runtime.appMetadata = app;
-    (0, _featureFlags.activateFeatures)(flags, this.agentIdentifier);
+
+    // set the agent runtime objects that require the rum response or entity guid
+    if (!Object.keys(this.agentRef.runtime.appMetadata).length) this.agentRef.runtime.appMetadata = app;
     this.drain();
     this.agentRef.runtime.harvester.startTimer();
+    (0, _featureFlags.activateFeatures)(flags, this.agentRef);
+  }
+  processEntities(entities, targetApp) {
+    if (!entities || !targetApp) return;
+    entities.forEach(agent => {
+      const entityManager = this.agentRef.runtime.entityManager;
+      const entityGuid = agent.entityGuid;
+      const entity = entityManager.get(entityGuid);
+      if (entity) return; // already processed
+
+      if ((0, _target.isContainerAgentTarget)(targetApp, this.agentRef)) {
+        entityManager.setDefaultEntity({
+          ...targetApp,
+          entityGuid
+        });
+      }
+      entityManager.set(agent.entityGuid, {
+        ...targetApp,
+        entityGuid
+      });
+    });
   }
 }
 exports.Aggregate = Aggregate;

package/dist/cjs/features/page_view_event/instrument/index.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.PageViewEvent = exports.Instrument = void 0;
+var _handle = require("../../../common/event-emitter/handle");
 var _instrumentBase = require("../../utils/instrument-base");
 var CONSTANTS = _interopRequireWildcard(require("../constants"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
@@ -17,6 +18,9 @@ class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = CONSTANTS.FEATURE_NAME;
   constructor(agentRef, auto = true) {
     super(agentRef, CONSTANTS.FEATURE_NAME, auto);
+
+    /** messages from the register API that can trigger a new RUM call */
+    this.ee.on('api-send-rum', (attrs, target) => (0, _handle.handle)('send-rum', [attrs, target], undefined, this.featureName, this.ee));
     this.importAggregator(agentRef);
   }
 }

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

@@ -223,6 +223,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
   }
   makeHarvestPayload(shouldRetryOnFail) {
+    const payloadOutput = {
+      targetApp: undefined,
+      payload: undefined
+    };
     if (this.mode !== _constants2.MODE.FULL || this.blocked) return;
     if (!this.recorder || !this.timeKeeper?.ready || !this.recorder.hasSeenSnapshot) return;
     const recorderEvents = this.recorder.getEvents();
@@ -231,7 +235,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     const payload = this.getHarvestContents(recorderEvents);
     if (!payload.body.length) {
       this.recorder.clearBuffer();
-      return;
+      return [payloadOutput];
     }
     this.reportSupportabilityMetric('SessionReplay/Harvest/Attempts');
     let len = 0;
@@ -268,7 +272,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     if (len > _agentConstants.MAX_PAYLOAD_SIZE) {
       this.abort(_constants.ABORT_REASONS.TOO_BIG, len);
-      return;
+      return [payloadOutput];
     }
     // TODO -- Gracefully handle the buffer for retries.
     if (!this.agentRef.runtime.session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({
@@ -276,10 +280,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
     });
     this.recorder.clearBuffer();
     if (recorderEvents.type === 'preloaded') this.agentRef.runtime.harvester.triggerHarvestFor(this);
-    return [{
-      targetApp: undefined,
-      payload
-    }]; // SR doesn't need a targetApp as it only works for the main, but format needs to make AggregateBase
+    payloadOutput.payload = payload;
+    return [payloadOutput];
   }
   getCorrectedTimestamp(node) {
     if (!node?.timestamp) return;

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

@@ -89,7 +89,7 @@ class Instrument extends _instrumentBase.InstrumentBase {
       });
       this.recorder.startRecording();
       this.abortHandler = this.recorder.stopRecording;
-    } catch (e) {}
+    } catch (e) {} // TODO add internal error handling
     this.importAggregator(this.#agentRef, {
       recorder: this.recorder,
       errorNoticed: this.errorNoticed

package/dist/cjs/features/session_replay/shared/recorder-events.js

@@ -26,8 +26,10 @@ class RecorderEvents {
   hasMeta = false;
   /** Payload metadata -- Should indicate that the payload being sent contains an error.  Used for query/filter purposes in UI */
   hasError = false;
-  /** Payload metadata -- Denotes whether all stylesheet elements were able to be inlined */
-  inlinedAllStylesheets = true;
+  constructor(shouldInlineStylesheets = true) {
+    /** Payload metadata -- Denotes whether all stylesheet elements were able to be inlined */
+    this.inlinedAllStylesheets = shouldInlineStylesheets;
+  }
   add(event) {
     this.#events.add(event);
   }

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

@@ -35,9 +35,14 @@ class Recorder {
   #warnCSSOnce = (0, _invoke.single)(() => (0, _console.warn)(47)); // notifies user of potential replayer issue if fix_stylesheets is off
 
   constructor(parent) {
-    this.#events = new _recorderEvents.RecorderEvents();
-    this.#backloggedEvents = new _recorderEvents.RecorderEvents();
-    this.#preloaded = [new _recorderEvents.RecorderEvents()];
+    /** The parent class that instantiated the recorder */
+    this.parent = parent;
+    /** A flag that can be set to false by failing conversions to stop the fetching process */
+    this.shouldFix = this.parent.agentRef.init.session_replay.fix_stylesheets;
+    /** Event Buffers */
+    this.#events = new _recorderEvents.RecorderEvents(this.shouldFix);
+    this.#backloggedEvents = new _recorderEvents.RecorderEvents(this.shouldFix);
+    this.#preloaded = [new _recorderEvents.RecorderEvents(this.shouldFix)];
     /** True when actively recording, false when paused or stopped */
     this.recording = false;
     /** The pointer to the current bucket holding rrweb events */
@@ -46,10 +51,6 @@ class Recorder {
     this.hasSeenSnapshot = false;
     /** Hold on to the last meta node, so that it can be re-inserted if the meta and snapshot nodes are broken up due to harvesting */
     this.lastMeta = false;
-    /** The parent class that instantiated the recorder */
-    this.parent = parent;
-    /** A flag that can be set to false by failing conversions to stop the fetching process */
-    this.shouldFix = this.parent.agentRef.init.session_replay.fix_stylesheets;
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
     this.stopRecording = () => {/* no-op until set by rrweb initializer */};
   }
@@ -76,8 +77,8 @@ class Recorder {
 
   /** Clears the buffer (this.#events), and resets all payload metadata properties */
   clearBuffer() {
-    if (this.#preloaded[0]?.events.length) this.#preloaded.shift();else if (this.parent.mode === _constants2.MODE.ERROR) this.#backloggedEvents = this.#events;else this.#backloggedEvents = new _recorderEvents.RecorderEvents();
-    this.#events = new _recorderEvents.RecorderEvents();
+    if (this.#preloaded[0]?.events.length) this.#preloaded.shift();else if (this.parent.mode === _constants2.MODE.ERROR) this.#backloggedEvents = this.#events;else this.#backloggedEvents = new _recorderEvents.RecorderEvents(this.shouldFix);
+    this.#events = new _recorderEvents.RecorderEvents(this.shouldFix);
   }
 
   /** Begin recording using configured recording lib */
@@ -129,7 +130,7 @@ class Recorder {
    */
   audit(event, isCheckout) {
     /** An count of stylesheet objects that were blocked from accessing contents via JS */
-    const incompletes = _stylesheetEvaluator.stylesheetEvaluator.evaluate();
+    const incompletes = this.parent.agentRef.init.session_replay.fix_stylesheets ? _stylesheetEvaluator.stylesheetEvaluator.evaluate() : 0;
     const missingInlineSMTag = 'SessionReplay/Payload/Missing-Inline-Css/';
     /** only run the full fixing behavior (more costly) if fix_stylesheets is configured as on (default behavior) */
     if (!this.shouldFix) {
@@ -205,7 +206,7 @@ class Recorder {
         this.parent.agentRef.runtime.harvester.triggerHarvestFor(this.parent);
       } else {
         // we are still in "preload" and it triggered a "stop point".  Make a new set, which will get pointed at on next cycle
-        this.#preloaded.push(new _recorderEvents.RecorderEvents());
+        this.#preloaded.push(new _recorderEvents.RecorderEvents(this.shouldFix));
       }
     }
   }

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

@@ -267,7 +267,7 @@ class TraceStorage {
   }
   get() {
     return [{
-      targetApp: this.parent.agentRef.mainAppKey,
+      targetApp: this.parent.agentRef.runtime.entityManager.get(),
       data: this.takeSTNs()
     }];
   }

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

@@ -31,7 +31,15 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.initialPageLoadInteraction.onDone.push(() => {
       // this ensures the .end() method also works with iPL
       this.initialPageLoadInteraction.forceSave = true; // unless forcibly ignored, iPL always finish by default
-      this.interactionsToHarvest.add(this.initialPageLoadInteraction);
+      const ixn = this.initialPageLoadInteraction;
+      /** this.events (ixns to harvest) has already been set up, use it immediately */
+      if (this.interactionsToHarvest) this.interactionsToHarvest.add(ixn);else {
+        /** this.events (ixns to harvest) hasnt been initialized yet... wait for it */
+        this.ee.on('entity-added', () => {
+          this.interactionsToHarvest = this.events;
+          this.interactionsToHarvest.add(ixn);
+        });
+      }
       this.initialPageLoadInteraction = null;
     });
     _timeToFirstByte.timeToFirstByte.subscribe(({
@@ -132,7 +140,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
     */
     if (this.interactionInProgress?.isActiveDuring(timestamp)) return this.interactionInProgress;
     let saveIxn;
-    const interactionsBuffer = this.interactionsToHarvest.get(this.agentRef.mainAppKey)[0].data;
+    const [{
+      data: interactionsBuffer
+    }] = this.interactionsToHarvest.get();
     for (let idx = interactionsBuffer.length - 1; idx >= 0; idx--) {
       // reverse search for the latest completed interaction for efficiency
       const finishedInteraction = interactionsBuffer[idx];

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

@@ -125,7 +125,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       }
     });
     if (agentRef.init.spa.enabled !== true) return;
-    state.initialPageLoad = new _interaction.Interaction('initialPageLoad', 0, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier);
+    state.initialPageLoad = new _interaction.Interaction('initialPageLoad', 0, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef);
     state.initialPageLoad.save = true;
     state.prevInteraction = state.initialPageLoad;
     state.currentNode = state.initialPageLoad.root; // hint
@@ -206,7 +206,7 @@ class Aggregate extends _aggregateBase.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.Interaction(evName, this[FN_START], state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier);
+        var ixn = new _interaction.Interaction(evName, this[FN_START], state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef);
 
         // Store the interaction as prevInteraction in case it is prematurely discarded
         state.prevInteraction = ixn;
@@ -504,7 +504,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }, this.featureName, promiseEE);
     (0, _registerHandler.registerHandler)(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.Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.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.Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef);
       if (!state.currentNode) {
         interaction.checkFinish();
         if (state.depth) setCurrentNode(interaction.root);

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

@@ -4,10 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Interaction = Interaction;
-var _info = require("../../../common/config/info");
 var _runtime = require("../../../common/constants/runtime");
 var _nreum = require("../../../common/window/nreum");
-var _contextualEe = require("../../../common/event-emitter/contextual-ee");
 var _interactionNode = require("./interaction-node");
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
@@ -17,11 +15,10 @@ var _interactionNode = require("./interaction-node");
 var originalSetTimeout = (0, _nreum.gosNREUMOriginals)().o.ST;
 var originalClearTimeout = (0, _nreum.gosNREUMOriginals)().o.CT;
 var lastId = {};
-function Interaction(eventName, timestamp, url, routeName, onFinished, agentIdentifier) {
-  this.agentIdentifier = agentIdentifier;
-  this.ee = _contextualEe.ee.get(agentIdentifier);
-  lastId[agentIdentifier] = 0;
-  this.id = ++lastId[agentIdentifier];
+function Interaction(eventName, timestamp, url, routeName, onFinished, agentRef) {
+  this.agentRef = agentRef;
+  lastId[agentRef.agentIdentifier] = 0;
+  this.id = ++lastId[agentRef.agentIdentifier];
   this.eventName = eventName;
   this.nodes = 0;
   this.remaining = 0;
@@ -89,9 +86,9 @@ InteractionPrototype.finish = function finishInteraction() {
   if (this.onFinished) {
     this.onFinished(this);
   }
-  Object.entries((0, _info.getInfo)(interaction.agentIdentifier).jsAttributes || {}).forEach(([attr, value]) => {
+  Object.entries(interaction.agentRef.info?.jsAttributes || {}).forEach(([attr, value]) => {
     if (!(attr in customAttrs)) customAttrs[attr] = value;
   });
   root.end = endTimestamp;
-  interaction.ee.emit('interaction', [this]);
+  interaction.agentRef.ee.emit('interaction', [this]);
 };

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

@@ -14,21 +14,47 @@ var _obfuscate = require("../../common/util/obfuscate");
 var _features = require("../../loaders/features/features");
 var _eventStoreManager = require("./event-store-manager");
 var _harvester = require("../../common/harvest/harvester");
+var _console = require("../../common/util/console");
+var _entityManager = require("./entity-manager");
+var _eventBuffer = require("./event-buffer");
 var _handle = require("../../common/event-emitter/handle");
 var _constants = require("../metrics/constants");
+var _eventAggregator = require("../../common/aggregate/event-aggregator");
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
 class AggregateBase extends _featureBase.FeatureBase {
+  /**
+   * Create an AggregateBase instance.
+   * @param {Object} agentRef The reference to the agent instance.
+   * @param {string} featureName The name of the feature creating the instance.
+   */
   constructor(agentRef, featureName) {
     super(agentRef.agentIdentifier, featureName);
     this.agentRef = agentRef;
     this.checkConfiguration(agentRef);
     this.doOnceForAllAggregate(agentRef);
+    this.harvestOpts = {}; // features aggregate classes can define custom opts for when their harvest is called
+
+    const agentEntityGuid = this.agentRef?.runtime?.appMetadata?.agents?.[0]?.entityGuid;
+    if (agentEntityGuid) {
+      this.#setupEventStore(agentEntityGuid); // if there's no entity guid, wont dont anything, and will wait for rum flags
+    } else {
+      this.ee.on('entity-added', entity => {
+        this.#setupEventStore(entity.entityGuid);
+      });
+    }
+  }
 
-    // This switch needs to be after doOnceForAllAggregate which may new sharedAggregator and reset mainAppKey.
+  /**
+   * sets up the event store for the feature.  It must wait for the entity guid to be available before setting up the event store.  This is called once the rum response is received with an entityGuid.
+   * @param {string} entityGuid
+   * @returns {void}
+   */
+  #setupEventStore(entityGuid) {
+    if (this.events || !entityGuid) return;
     switch (this.featureName) {
       // SessionTrace + Replay have their own storage mechanisms.
       case _features.FEATURE_NAMES.sessionTrace:
@@ -37,16 +63,15 @@ class AggregateBase extends _featureBase.FeatureBase {
       // Jserror and Metric features uses a singleton EventAggregator instead of a regular EventBuffer.
       case _features.FEATURE_NAMES.jserrors:
       case _features.FEATURE_NAMES.metrics:
-        this.events = agentRef.sharedAggregator;
+        this.events = this.agentRef.sharedAggregator ??= new _eventStoreManager.EventStoreManager(this.agentRef, _eventAggregator.EventAggregator, entityGuid, 'shared_aggregator');
         break;
       /** All other features get EventBuffer in the ESM by default. Note: PVE is included here, but event buffer will always be empty so future harvests will still not happen by interval or EOL.
       This was necessary to prevent race cond. issues where the event buffer was checked before the feature could "block" itself.
       Its easier to just keep an empty event buffer in place. */
       default:
-        this.events = new _eventStoreManager.EventStoreManager(agentRef.mainAppKey, 1, agentRef.agentIdentifier, this.featureName);
+        this.events = new _eventStoreManager.EventStoreManager(this.agentRef, _eventBuffer.EventBuffer, entityGuid, this.featureName);
         break;
     }
-    this.harvestOpts = {}; // features aggregate classes can define custom opts for when their harvest is called
   }
 
   /**
@@ -76,6 +101,10 @@ class AggregateBase extends _featureBase.FeatureBase {
       this.deregisterDrain();
     });
   }
+
+  /**
+   * Stages the feature to be drained
+   */
   drain() {
     (0, _drain.drain)(this.agentIdentifier, this.featureName);
     this.drained = true;
@@ -87,28 +116,29 @@ class AggregateBase extends _featureBase.FeatureBase {
   /**
    * Return harvest payload. A "serializer" function can be defined on a derived class to format the payload.
    * @param {Boolean} shouldRetryOnFail - harvester flag to backup payload for retry later if harvest request fails; this should be moved to harvester logic
-   * @param {object|undefined} opts.target - the target app passed onto the event store manager to determine which app's data to return; if none provided, all apps data will be returned
+   * @param {object|undefined} opts - opts passed from the harvester to help form the payload
+   * @param {string} opts.targetEntityGuid - the entity guid of the target app
    * @returns {Array} Final payload tagged with their targeting browser app. The value of `payload` can be undefined if there are no pending events for an app. This should be a minimum length of 1.
    */
   makeHarvestPayload(shouldRetryOnFail = false, opts = {}) {
-    if (this.events.isEmpty(this.harvestOpts, opts.target)) return;
+    if (!this.events || this.events.isEmpty(this.harvestOpts, opts.targetEntityGuid)) return;
     // Other conditions and things to do when preparing harvest that is required.
     if (this.preHarvestChecks && !this.preHarvestChecks(opts)) return;
-    if (shouldRetryOnFail) this.events.save(this.harvestOpts, opts.target);
-    const returnedDataArr = this.events.get(this.harvestOpts, opts.target);
-    if (!returnedDataArr.length) throw new Error('Unexpected problem encountered. There should be at least one app for harvest!');
-    this.events.clear(this.harvestOpts, opts.target);
+    if (shouldRetryOnFail) this.events.save(this.harvestOpts, opts.targetEntityGuid);
+    const returnedDataArr = this.events.get(this.harvestOpts, opts.targetEntityGuid);
+    if (!returnedDataArr.length) return (0, _console.warn)(52);
+    this.events.clear(this.harvestOpts, opts.targetEntityGuid);
     return returnedDataArr.map(({
       targetApp,
       data
     }) => {
       // A serializer or formatter assists in creating the payload `body` from stored events on harvest when defined by derived feature class.
-      const body = this.serializer ? this.serializer(data) : data;
+      const body = this.serializer ? this.serializer(data, targetApp?.entityGuid) : data;
       const payload = {
         body
       };
       // Constructs the payload `qs` for relevant features on harvest.
-      if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(data);
+      if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(data, targetApp?.entityGuid);
       return {
         targetApp,
         payload
@@ -119,11 +149,15 @@ class AggregateBase extends _featureBase.FeatureBase {
   /**
    * Cleanup task after a harvest.
    * @param {object} result - the cbResult object from the harvester's send method
+   * @param {object=} result.targetApp - the target app object that was used to point the harvest to the correct app
+   * @param {string=} result.targetApp.entityGuid - the entity guid of the target app
+   * @param {boolean=} result.sent - whether the harvest was sent successfully
+   * @param {boolean=} result.retry - whether the harvest should be retried
    */
   postHarvestCleanup(result = {}) {
     const harvestFailed = result.sent && result.retry;
-    if (harvestFailed) this.events.reloadSave(this.harvestOpts, result.targetApp);
-    this.events.clearSave(this.harvestOpts, result.targetApp);
+    if (harvestFailed) this.events.reloadSave(this.harvestOpts, result.targetApp?.entityGuid);
+    this.events.clearSave(this.harvestOpts, result.targetApp?.entityGuid);
   }
 
   /**
@@ -163,12 +197,7 @@ class AggregateBase extends _featureBase.FeatureBase {
   doOnceForAllAggregate(agentRef) {
     if (!agentRef.runtime.obfuscator) agentRef.runtime.obfuscator = new _obfuscate.Obfuscator(agentRef);
     this.obfuscator = agentRef.runtime.obfuscator;
-    if (!agentRef.mainAppKey) agentRef.mainAppKey = {
-      licenseKey: agentRef.info.licenseKey,
-      appId: agentRef.info.applicationID
-    };
-    // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
-    if (!agentRef.sharedAggregator) agentRef.sharedAggregator = new _eventStoreManager.EventStoreManager(agentRef.mainAppKey, 2, agentRef.agentIdentifier, 'shared_aggregator');
+    if (!agentRef.runtime.entityManager) agentRef.runtime.entityManager = new _entityManager.EntityManager(this.agentRef);
     if (!agentRef.runtime.harvester) agentRef.runtime.harvester = new _harvester.Harvester(agentRef);
   }
 

package/dist/cjs/features/utils/entity-manager.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EntityManager = void 0;
+/**
+ * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+class EntityManager {
+  #entities = new Map();
+  #entityGuidLookup = {};
+  #defaultEntity = null;
+  constructor(agentRef) {
+    this.agentRef = agentRef;
+    this.#defaultEntity = {
+      licenseKey: agentRef.info.licenseKey,
+      applicationID: agentRef.info.applicationID
+    };
+  }
+  get(entityGuid) {
+    if (!entityGuid) return this.#defaultEntity;
+    return this.#entities.get(entityGuid);
+  }
+  getEntityGuidFor(licenseKey, applicationID) {
+    if (!this.#entityGuidLookup[licenseKey] || !this.#entityGuidLookup[applicationID]) return;
+    return this.#entityGuidLookup[licenseKey].filter(x => this.#entityGuidLookup[applicationID].includes(x))[0];
+  }
+  set(entityGuid, entity) {
+    if (this.#entities.has(entityGuid)) return;
+    this.#entities.set(entityGuid, entity);
+    this.#entityGuidLookup[entity.licenseKey] ??= [];
+    this.#entityGuidLookup[entity.licenseKey].push(entityGuid);
+    this.#entityGuidLookup[entity.applicationID] ??= [];
+    this.#entityGuidLookup[entity.applicationID].push(entityGuid);
+    this.agentRef.ee.emit('entity-added', [entity]);
+  }
+  clear() {
+    this.#entities.clear();
+  }
+  setDefaultEntity(entity) {
+    this.#defaultEntity = entity;
+  }
+}
+exports.EntityManager = EntityManager;