@newrelic/browser-agent 1.286.0 → 1.288.0

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

@@ -13,6 +13,7 @@ var _log = require("../shared/log");
 var _utils = require("../shared/utils");
 var _traverse = require("../../../common/util/traverse");
 var _agentConstants = require("../../../common/constants/agent-constants");
+var _target = require("../../../common/util/target");
 var _constants2 = require("../../../common/session/constants");
 var _constants3 = require("../../session_replay/constants");
 var _featureGates = require("../../utils/feature-gates");
@@ -62,7 +63,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
       loggingMode: this.loggingMode
     });
   }
-  handleLog(timestamp, message, attributes = {}, level = _constants.LOG_LEVELS.INFO) {
+  handleLog(timestamp, message, attributes = {}, level = _constants.LOG_LEVELS.INFO, targetEntityGuid) {
+    if (!this.agentRef.runtime.entityManager.get(targetEntityGuid)) return (0, _console.warn)(56, this.featureName);
     if (this.blocked || !this.loggingMode) return;
     if (!attributes || typeof attributes !== 'object') attributes = {};
     if (typeof level === 'string') level = level.toUpperCase();
@@ -97,11 +99,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
       (0, _console.warn)(31, log.message.slice(0, 25) + '...');
       return;
     }
-    if (this.events.wouldExceedMaxSize(logBytes)) {
+    if (this.events.wouldExceedMaxSize(logBytes, targetEntityGuid)) {
       this.reportSupportabilityMetric('Logging/Harvest/Early/Seen', this.events.byteSize() + logBytes);
-      this.agentRef.runtime.harvester.triggerHarvestFor(this); // force a harvest synchronously to try adding again
+      this.agentRef.runtime.harvester.triggerHarvestFor(this, {
+        targetEntityGuid
+      }); // force a harvest synchronously to try adding again
     }
-    if (!this.events.add(log)) {
+    if (!this.events.add(log, targetEntityGuid)) {
       // still failed after a harvest attempt despite not being too large would mean harvest failed with options.retry
       this.reportSupportabilityMetric(failToHarvestMessage, logBytes);
       (0, _console.warn)(31, log.message.slice(0, 25) + '...');
@@ -109,24 +113,25 @@ class Aggregate extends _aggregateBase.AggregateBase {
       this.reportSupportabilityMetric('Logging/Event/Added/Seen');
     }
   }
-  serializer(eventBuffer) {
+  serializer(eventBuffer, targetEntityGuid) {
+    const target = this.agentRef.runtime.entityManager.get(targetEntityGuid);
     const sessionEntity = this.agentRef.runtime.session;
     return [{
       common: {
         /** Attributes in the `common` section are added to `all` logs generated in the payload */
         attributes: {
-          'entity.guid': this.agentRef.runtime.appMetadata?.agents?.[0]?.entityGuid,
-          // browser entity guid as provided from RUM response
+          'entity.guid': target.entityGuid,
+          // browser entity guid as provided API target OR the default from RUM response if not supplied
           ...(sessionEntity && {
             session: sessionEntity.state.value || '0',
             // The session ID that we generate and keep across page loads
-            hasReplay: sessionEntity.state.sessionReplayMode === 1,
+            hasReplay: sessionEntity.state.sessionReplayMode === 1 && (0, _target.isContainerAgentTarget)(target, this.agentRef),
             // True if a session replay recording is running
             hasTrace: sessionEntity.state.sessionTraceMode === 1 // True if a session trace recording is running
           }),
           ptid: this.agentRef.runtime.ptid,
           // page trace id
-          appId: this.agentRef.info.applicationID,
+          appId: target.applicationID || this.agentRef.info.applicationID,
           // Application ID from info object,
           standalone: Boolean(this.agentRef.info.sa),
           // copy paste (true) vs APM (false)
@@ -144,9 +149,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
       logs: (0, _traverse.applyFnToProps)(eventBuffer, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
     }];
   }
-  queryStringsBuilder() {
+  queryStringsBuilder(_, targetEntityGuid) {
+    const target = this.agentRef.runtime.entityManager.get(targetEntityGuid);
     return {
-      browser_monitoring_key: this.agentRef.info.licenseKey
+      browser_monitoring_key: target.licenseKey
     };
   }
 
@@ -154,8 +160,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
   abort(reason = {}) {
     this.reportSupportabilityMetric("Logging/Abort/".concat(reason.sm));
     this.blocked = true;
-    this.events.clear();
-    this.events.clearSave();
+    if (this.events) {
+      this.events.clear();
+      this.events.clearSave();
+    }
     this.updateLoggingMode(_constants.LOGGING_MODE.OFF);
     this.deregisterDrain();
   }

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

@@ -50,7 +50,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.recorder = args?.recorder;
     this.errorNoticed = args?.errorNoticed || false;
     this.harvestOpts.raw = true;
-    this.isSessionTrackingEnabled = (0, _featureGates.canEnableSessionTracking)(this.agentIdentifier) && this.agentRef.runtime.session;
+    this.isSessionTrackingEnabled = (0, _featureGates.canEnableSessionTracking)(this.agentIdentifier) && !!this.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.
@@ -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 */
@@ -116,6 +117,7 @@ class Recorder {
     });
     this.stopRecording = () => {
       this.recording = false;
+      this.notified = false;
       this.parent.ee.emit(_constants.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [false, this.parent.mode]);
       stop?.();
     };
@@ -129,7 +131,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) {
@@ -163,6 +165,10 @@ class Recorder {
   /** Store a payload in the buffer (this.#events).  This should be the callback to the recording lib noticing a mutation */
   store(event, isCheckout) {
     if (!event) return;
+    if (this.parent.agentRef.runtime?.session?.isAfterSessionExpiry(event.timestamp)) {
+      this.parent.reportSupportabilityMetric('Session/Expired/SessionReplay/Seen');
+      return;
+    }
     if (!(this.parent instanceof _aggregateBase.AggregateBase) && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1];else this.currentBufferTarget = this.#events;
     if (this.parent.blocked) return;
     if (!this.notified) {
@@ -205,7 +211,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

@@ -53,6 +53,9 @@ class TraceStorage {
   constructor(parent) {
     this.parent = parent;
   }
+  isAfterSessionExpiry(entryTimestamp) {
+    return this.parent.agentRef.runtime?.session?.isAfterSessionExpiry((this.parent.timeKeeper?.ready && this.parent.timeKeeper.convertRelativeTimestamp(entryTimestamp)) ?? undefined);
+  }
 
   /** Central function called by all the other store__ & addToTrace API to append a trace node. */
   storeSTN(stn) {
@@ -63,6 +66,10 @@ class TraceStorage {
       const openedSpace = this.trimSTNs(ERROR_MODE_SECONDS_WINDOW); // but maybe we could make some space by discarding irrelevant nodes if we're in sessioned Error mode
       if (openedSpace === 0) return;
     }
+    if (this.isAfterSessionExpiry(stn.s)) {
+      this.parent.reportSupportabilityMetric('Session/Expired/SessionTrace/Seen');
+      return;
+    }
     if (this.trace[stn.n]) this.trace[stn.n].push(stn);else this.trace[stn.n] = [stn];
     if (stn.s < this.earliestTimeStamp) this.earliestTimeStamp = stn.s;
     if (stn.s > this.latestTimeStamp) this.latestTimeStamp = stn.s;
@@ -267,7 +274,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

@@ -30,8 +30,17 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.initialPageLoadInteraction = new _initialPageLoadInteraction.InitialPageLoadInteraction(agentRef.agentIdentifier);
     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
       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 +141,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,8 +125,9 @@ 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;
+    if (agentRef.runtime.session?.isNew) state.initialPageLoad.root.attrs.custom.isFirstOfSession = true; // mark the hard page load as first of its session
     state.prevInteraction = state.initialPageLoad;
     state.currentNode = state.initialPageLoad.root; // hint
     // ensure that checkFinish calls are safe during initialPageLoad
@@ -206,7 +207,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 +505,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]);
 };