@newrelic/browser-agent 1.286.0 → 1.288.0

package/src/features/jserrors/aggregate/index.js

@@ -19,6 +19,8 @@ import { AggregateBase } from '../../utils/aggregate-base'
 import { now } from '../../../common/timing/now'
 import { applyFnToProps } from '../../../common/util/traverse'
 import { evaluateInternalError } from './internal-errors'
+import { isContainerAgentTarget } from '../../../common/util/target'
+import { warn } from '../../../common/util/console'
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
@@ -107,10 +109,13 @@ export class Aggregate extends AggregateBase {
    * @param {object=} customAttributes  any custom attributes to be included in the error payload
    * @param {boolean=} hasReplay a flag indicating if the error occurred during a replay session
    * @param {string=} swallowReason a string indicating pre-defined reason if swallowing the error.  Mainly used by the internal error SMs.
+   * @param {object=} target the target to buffer and harvest to, if undefined the default configuration target is used
    * @returns
    */
-  storeError (err, time, internal, customAttributes, hasReplay, swallowReason) {
+  storeError (err, time, internal, customAttributes, hasReplay, swallowReason, targetEntityGuid) {
     if (!err) return
+    const target = this.agentRef.runtime.entityManager.get(targetEntityGuid)
+    if (!target) return warn(56, this.featureName)
     // are we in an interaction
     time = time || now()
     let filterOutput
@@ -145,7 +150,8 @@ export class Aggregate extends AggregateBase {
     // Do not modify the name ('errorGroup') of params without DEM approval!
     if (filterOutput?.group) params.errorGroup = filterOutput.group
 
-    if (hasReplay) params.hasReplay = hasReplay
+    // Should only decorate "hasReplay" for the container agent, so check if the target matches the config
+    if (hasReplay && isContainerAgentTarget(target, this.agentRef)) params.hasReplay = hasReplay
     /**
      * The bucketHash is different from the params.stackHash because the params.stackHash is based on the canonicalized
      * stack trace and is used downstream in NR1 to attempt to group the same errors across different browsers. However,
@@ -181,7 +187,7 @@ export class Aggregate extends AggregateBase {
 
     // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
     const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes]
-    handle('trace-jserror', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
+    if (this.shouldAllowMainAgentToCapture(targetEntityGuid)) handle('trace-jserror', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return
 
@@ -190,27 +196,32 @@ export class Aggregate extends AggregateBase {
       params._interactionNodeId = err.__newrelic[this.agentIdentifier].interactionNodeId
     }
 
-    const softNavInUse = Boolean(this.agentRef.features?.[FEATURE_NAMES.softNav])
-    // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
-    // They each will also tack on their respective properties to the params object as part of the decision flow.
-    if (softNavInUse) handle('jserror', [params, time], undefined, FEATURE_NAMES.softNav, this.ee)
-    else handle('spa-jserror', jsErrorEvent, undefined, FEATURE_NAMES.spa, this.ee)
-
-    if (params.browserInteractionId && !params._softNavFinished) { // hold onto the error until the in-progress interaction is done, eithered saved or discarded
-      this.bufferedErrorsUnderSpa[params.browserInteractionId] ??= []
-      this.bufferedErrorsUnderSpa[params.browserInteractionId].push(jsErrorEvent)
-    } else if (params._interactionId != null) { // same as above, except tailored for the way old spa does it
-      this.bufferedErrorsUnderSpa[params._interactionId] = this.bufferedErrorsUnderSpa[params._interactionId] || []
-      this.bufferedErrorsUnderSpa[params._interactionId].push(jsErrorEvent)
-    } else {
+    if (this.shouldAllowMainAgentToCapture(targetEntityGuid)) {
+      const softNavInUse = Boolean(this.agentRef.features?.[FEATURE_NAMES.softNav])
+      // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
+      // They each will also tack on their respective properties to the params object as part of the decision flow.
+      if (softNavInUse) handle('jserror', [params, time], undefined, FEATURE_NAMES.softNav, this.ee)
+      else handle('spa-jserror', jsErrorEvent, undefined, FEATURE_NAMES.spa, this.ee)
+
+      if (params.browserInteractionId && !params._softNavFinished) { // hold onto the error until the in-progress interaction is done, eithered saved or discarded
+        this.bufferedErrorsUnderSpa[params.browserInteractionId] ??= []
+        this.bufferedErrorsUnderSpa[params.browserInteractionId].push(jsErrorEvent)
+      } else if (params._interactionId != null) { // same as above, except tailored for the way old spa does it
+        this.bufferedErrorsUnderSpa[params._interactionId] = this.bufferedErrorsUnderSpa[params._interactionId] || []
+        this.bufferedErrorsUnderSpa[params._interactionId].push(jsErrorEvent)
+      } else {
       // Either there is no interaction (then all these params properties will be undefined) OR there's a related soft navigation that's already completed.
       // The old spa does not look up completed interactions at all, so there's no need to consider it.
-      this.#storeJserrorForHarvest(jsErrorEvent, params.browserInteractionId !== undefined, params._softNavAttributes)
+        this.#storeJserrorForHarvest(jsErrorEvent, params.browserInteractionId !== undefined, params._softNavAttributes)
+      }
     }
+
+    // always add directly if scoped to a sub-entity, the other pathways above will be deterministic if the main agent should procede
+    if (targetEntityGuid) this.#storeJserrorForHarvest([...jsErrorEvent, targetEntityGuid], false, params._softNavAttributes)
   }
 
   #storeJserrorForHarvest (errorInfoArr, softNavOccurredFinished, softNavCustomAttrs = {}) {
-    let [type, bucketHash, params, newMetrics, localAttrs] = errorInfoArr
+    let [type, bucketHash, params, newMetrics, localAttrs, targetEntityGuid] = errorInfoArr
     const allCustomAttrs = {}
 
     if (softNavOccurredFinished) {
@@ -227,13 +238,24 @@ export class Aggregate extends AggregateBase {
 
     const jsAttributesHash = stringHashCode(stringify(allCustomAttrs))
     const aggregateHash = bucketHash + ':' + jsAttributesHash
-    this.events.add([type, aggregateHash, params, newMetrics, allCustomAttrs])
+
+    this.events.add([type, aggregateHash, params, newMetrics, allCustomAttrs], targetEntityGuid)
 
     function setCustom (key, val) {
       allCustomAttrs[key] = (val && typeof val === 'object' ? stringify(val) : val)
     }
   }
 
+  /**
+  * If the event lacks an entityGuid (the default behavior), the main agent should capture the data. If the data is assigned to a sub-entity target
+  * the main agent should not capture events unless it is configured to do so.
+  * @param {string} entityGuid - the context object for the event
+  * @returns {boolean} - whether the main agent should capture the event to its internal target
+  */
+  shouldAllowMainAgentToCapture (entityGuid) {
+    return (!entityGuid || this.agentRef.init.api.duplicate_registered_data)
+  }
+
   // TO-DO: Remove this function when old spa is taken out. #storeJserrorForHarvest handles the work with the softnav feature.
   onInteractionDone (interaction, wasSaved) {
     if (!this.bufferedErrorsUnderSpa[interaction.id] || this.blocked) return
@@ -257,7 +279,7 @@ export class Aggregate extends AggregateBase {
       var jsAttributesHash = stringHashCode(stringify(allCustomAttrs))
       var aggregateHash = hash + ':' + jsAttributesHash
 
-      this.events.add([item[0], aggregateHash, params, item[3], allCustomAttrs])
+      this.events.add([item[0], aggregateHash, params, item[3], allCustomAttrs], item[5])
 
       function setCustom ([key, val]) {
         allCustomAttrs[key] = (val && typeof val === 'object' ? stringify(val) : val)

package/src/features/logging/aggregate/index.js

@@ -11,6 +11,7 @@ import { Log } from '../shared/log'
 import { isValidLogLevel } from '../shared/utils'
 import { applyFnToProps } from '../../../common/util/traverse'
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
+import { isContainerAgentTarget } from '../../../common/util/target'
 import { SESSION_EVENT_TYPES, SESSION_EVENTS } from '../../../common/session/constants'
 import { ABORT_REASONS } from '../../session_replay/constants'
 import { canEnableSessionTracking } from '../../utils/feature-gates'
@@ -61,7 +62,8 @@ export class Aggregate extends AggregateBase {
     })
   }
 
-  handleLog (timestamp, message, attributes = {}, level = LOG_LEVELS.INFO) {
+  handleLog (timestamp, message, attributes = {}, level = LOG_LEVELS.INFO, targetEntityGuid) {
+    if (!this.agentRef.runtime.entityManager.get(targetEntityGuid)) return warn(56, this.featureName)
     if (this.blocked || !this.loggingMode) return
 
     if (!attributes || typeof attributes !== 'object') attributes = {}
@@ -105,12 +107,12 @@ export class Aggregate extends AggregateBase {
       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)) { // still failed after a harvest attempt despite not being too large would mean harvest failed with options.retry
+    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)
       warn(31, log.message.slice(0, 25) + '...')
     } else {
@@ -118,20 +120,21 @@ export class Aggregate extends AggregateBase {
     }
   }
 
-  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, // True if a session replay recording is running
+            hasReplay: sessionEntity.state.sessionReplayMode === 1 && 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, // Application ID from info object,
+          appId: target.applicationID || this.agentRef.info.applicationID, // Application ID from info object,
           standalone: Boolean(this.agentRef.info.sa), // copy paste (true) vs APM (false)
           agentVersion: this.agentRef.runtime.version, // browser agent version
           // The following 3 attributes are evaluated and dropped at ingest processing time and do not get stored on NRDB:
@@ -150,16 +153,19 @@ export class Aggregate extends AggregateBase {
     }]
   }
 
-  queryStringsBuilder () {
-    return { browser_monitoring_key: this.agentRef.info.licenseKey }
+  queryStringsBuilder (_, targetEntityGuid) {
+    const target = this.agentRef.runtime.entityManager.get(targetEntityGuid)
+    return { browser_monitoring_key: target.licenseKey }
   }
 
   /** Abort the feature, once aborted it will not resume */
   abort (reason = {}) {
     this.reportSupportabilityMetric(`Logging/Abort/${reason.sm}`)
     this.blocked = true
-    this.events.clear()
-    this.events.clearSave()
+    if (this.events) {
+      this.events.clear()
+      this.events.clearSave()
+    }
     this.updateLoggingMode(LOGGING_MODE.OFF)
     this.deregisterDrain()
   }

package/src/features/logging/shared/utils.js

@@ -13,10 +13,11 @@ import { LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../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
    */
-export function bufferLog (ee, message, customAttributes = {}, level = LOG_LEVELS.INFO) {
+export function bufferLog (ee, message, customAttributes = {}, level = LOG_LEVELS.INFO, targetEntityGuid, timestamp = now()) {
   handle(SUPPORTABILITY_METRIC_CHANNEL, [`API/logging/${level.toLowerCase()}/called`], undefined, FEATURE_NAMES.metrics, ee)
-  handle(LOGGING_EVENT_EMITTER_CHANNEL, [now(), message, customAttributes, level], undefined, FEATURE_NAMES.logging, ee)
+  handle(LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, targetEntityGuid], undefined, FEATURE_NAMES.logging, ee)
 }
 
 /**

package/src/features/metrics/aggregate/index.js

@@ -21,8 +21,14 @@ export class Aggregate extends 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 = 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
@@ -33,9 +39,6 @@ export class Aggregate extends AggregateBase {
     // Allow features external to the metrics feature to capture SMs and CMs through the event emitter
     registerHandler(SUPPORTABILITY_METRIC_CHANNEL, this.storeSupportabilityMetrics.bind(this), this.featureName, this.ee)
     registerHandler(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 } // only allow any metrics to be sent after we get the right RUM flag and only on EoL
@@ -65,8 +68,7 @@ export class Aggregate extends AggregateBase {
     if (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/src/features/page_view_event/aggregate/index.js

@@ -17,6 +17,8 @@ import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte'
 import { now } from '../../../common/timing/now'
 import { TimeKeeper } from '../../../common/timing/time-keeper'
 import { applyFnToProps } from '../../../common/util/traverse'
+import { registerHandler } from '../../../common/event-emitter/register-handler'
+import { isContainerAgentTarget } from '../../../common/util/target'
 
 export class Aggregate extends AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME
@@ -27,6 +29,10 @@ export class Aggregate extends AggregateBase {
     this.firstByteToWindowLoad = 0 // our "frontend" duration
     this.firstByteToDomContent = 0 // our "dom processing" duration
 
+    registerHandler('send-rum', (customAttibutes, target) => {
+      this.sendRum(customAttibutes, target)
+    }, this.featureName, this.ee)
+
     if (!isValid(agentRef.agentIdentifier)) {
       this.ee.abort()
       return warn(43)
@@ -48,7 +54,13 @@ export class Aggregate extends AggregateBase {
     }
   }
 
-  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 = {}
 
@@ -77,8 +89,8 @@ export class Aggregate extends 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) {
-      body = applyFnToProps({ ja: info.jsAttributes }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
+    if (typeof customAttributes === 'object' && Object.keys(customAttributes).length > 0) {
+      body = applyFnToProps({ ja: customAttributes }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
     }
 
     if (globalScope.performance) {
@@ -107,9 +119,10 @@ export class Aggregate extends AggregateBase {
     }
 
     this.rumStartTime = now()
+
     this.agentRef.runtime.harvester.triggerHarvestFor(this, {
       directSend: {
-        targetApp: this.agentRef.mainAppKey,
+        targetApp: target,
         payload: { qs: queryParameters, body }
       },
       needResponse: true,
@@ -117,8 +130,19 @@ export class Aggregate extends AggregateBase {
     })
   }
 
-  postHarvestCleanup ({ status, responseText, xhr }) {
+  postHarvestCleanup ({ status, responseText, xhr, targetApp }) {
     const rumEndTime = 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
+      warn(53, error)
+    }
+
+    /** Only run agent-wide side-effects if the harvest was for the main agent */
+    if (!isContainerAgentTarget(targetApp, this.agentRef)) return
 
     if (status >= 400 || status === 0) {
       warn(18, status)
@@ -127,8 +151,8 @@ export class Aggregate extends AggregateBase {
       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) {
@@ -136,9 +160,27 @@ export class Aggregate extends AggregateBase {
       warn(17, error)
       return
     }
-    this.agentRef.runtime.appMetadata = app
-    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()
+    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 (isContainerAgentTarget(targetApp, this.agentRef)) {
+        entityManager.setDefaultEntity({ ...targetApp, entityGuid })
+      }
+      entityManager.set(agent.entityGuid, { ...targetApp, entityGuid })
+    })
   }
 }

package/src/features/page_view_event/instrument/index.js

@@ -2,6 +2,7 @@
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
+import { handle } from '../../../common/event-emitter/handle'
 import { InstrumentBase } from '../../utils/instrument-base'
 import * as CONSTANTS from '../constants'
 
@@ -10,6 +11,9 @@ export class Instrument extends InstrumentBase {
   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) => handle('send-rum', [attrs, target], undefined, this.featureName, this.ee))
+
     this.importAggregator(agentRef)
   }
 }

package/src/features/session_replay/aggregate/index.js

@@ -48,7 +48,7 @@ export class Aggregate extends AggregateBase {
     this.errorNoticed = args?.errorNoticed || false
     this.harvestOpts.raw = true
 
-    this.isSessionTrackingEnabled = canEnableSessionTracking(this.agentIdentifier) && this.agentRef.runtime.session
+    this.isSessionTrackingEnabled = canEnableSessionTracking(this.agentIdentifier) && !!this.agentRef.runtime.session
 
     this.reportSupportabilityMetric('Config/SessionReplay/Enabled')
 
@@ -213,6 +213,7 @@ export class Aggregate extends AggregateBase {
   }
 
   makeHarvestPayload (shouldRetryOnFail) {
+    const payloadOutput = { targetApp: undefined, payload: undefined }
     if (this.mode !== MODE.FULL || this.blocked) return
     if (!this.recorder || !this.timeKeeper?.ready || !this.recorder.hasSeenSnapshot) return
 
@@ -223,7 +224,7 @@ export class Aggregate extends AggregateBase {
     const payload = this.getHarvestContents(recorderEvents)
     if (!payload.body.length) {
       this.recorder.clearBuffer()
-      return
+      return [payloadOutput]
     }
 
     this.reportSupportabilityMetric('SessionReplay/Harvest/Attempts')
@@ -253,13 +254,15 @@ export class Aggregate extends AggregateBase {
 
     if (len > MAX_PAYLOAD_SIZE) {
       this.abort(ABORT_REASONS.TOO_BIG, len)
-      return
+      return [payloadOutput]
     }
     // TODO -- Gracefully handle the buffer for retries.
     if (!this.agentRef.runtime.session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({ sessionReplaySentFirstChunk: true })
     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) {

package/src/features/session_replay/instrument/index.js

@@ -80,7 +80,7 @@ export class Instrument extends InstrumentBase {
       this.recorder ??= new Recorder({ mode: this.#mode, agentIdentifier: this.agentIdentifier, trigger, ee: this.ee, agentRef: this.#agentRef })
       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/src/features/session_replay/shared/recorder-events.js

@@ -20,8 +20,11 @@ export 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/src/features/session_replay/shared/recorder.js

@@ -30,9 +30,14 @@ export class Recorder {
   #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()
-    this.#preloaded = [new 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(this.shouldFix)
+    this.#backloggedEvents = new RecorderEvents(this.shouldFix)
+    this.#preloaded = [new RecorderEvents(this.shouldFix)]
     /** True when actively recording, false when paused or stopped */
     this.recording = false
     /** The pointer to the current bucket holding rrweb events */
@@ -41,10 +46,6 @@ export 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 */ }
   }
@@ -74,8 +75,8 @@ export class Recorder {
   clearBuffer () {
     if (this.#preloaded[0]?.events.length) this.#preloaded.shift()
     else if (this.parent.mode === MODE.ERROR) this.#backloggedEvents = this.#events
-    else this.#backloggedEvents = new RecorderEvents()
-    this.#events = new RecorderEvents()
+    else this.#backloggedEvents = new RecorderEvents(this.shouldFix)
+    this.#events = new RecorderEvents(this.shouldFix)
   }
 
   /** Begin recording using configured recording lib */
@@ -105,6 +106,7 @@ export class Recorder {
 
     this.stopRecording = () => {
       this.recording = false
+      this.notified = false
       this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [false, this.parent.mode])
       stop?.()
     }
@@ -118,7 +120,7 @@ export class Recorder {
    */
   audit (event, isCheckout) {
     /** An count of stylesheet objects that were blocked from accessing contents via JS */
-    const incompletes = stylesheetEvaluator.evaluate()
+    const incompletes = this.parent.agentRef.init.session_replay.fix_stylesheets ? 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) {
@@ -152,6 +154,10 @@ export 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) && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1]
     else this.currentBufferTarget = this.#events
@@ -199,7 +205,7 @@ export 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())
+        this.#preloaded.push(new RecorderEvents(this.shouldFix))
       }
     }
   }

package/src/features/session_trace/aggregate/trace/storage.js

@@ -41,6 +41,10 @@ export class TraceStorage {
     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) {
     if (this.parent.blocked) return
@@ -49,6 +53,10 @@ export 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]
@@ -259,7 +267,7 @@ export class TraceStorage {
   }
 
   get () {
-    return [{ targetApp: this.parent.agentRef.mainAppKey, data: this.takeSTNs() }]
+    return [{ targetApp: this.parent.agentRef.runtime.entityManager.get(), data: this.takeSTNs() }]
   }
 
   clear () {

package/src/features/soft_navigations/aggregate/index.js

@@ -23,8 +23,18 @@ export class Aggregate extends AggregateBase {
 
     this.initialPageLoadInteraction = new 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.subscribe(({ attrs }) => {
@@ -131,7 +141,7 @@ export class Aggregate extends 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]
       if (finishedInteraction.isActiveDuring(timestamp)) {

package/src/features/spa/aggregate/index.js

@@ -108,8 +108,9 @@ export class Aggregate extends AggregateBase {
 
     if (agentRef.init.spa.enabled !== true) return
 
-    state.initialPageLoad = new Interaction('initialPageLoad', 0, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier)
+    state.initialPageLoad = new 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
@@ -199,7 +200,7 @@ export class Aggregate extends AggregateBase {
         // Otherwise, if no interaction is currently active, create a new node ID,
         // and let the aggregator know that we entered a new event handler callback
         // so that it has a chance to possibly start an interaction.
-        var ixn = new Interaction(evName, this[FN_START], state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier)
+        var ixn = new 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
@@ -535,7 +536,7 @@ export class Aggregate extends AggregateBase {
       var interaction
       if (state?.currentNode?.[INTERACTION]) interaction = this.ixn = state.currentNode[INTERACTION]
       else if (state?.prevNode?.end === null && state?.prevNode?.[INTERACTION]?.root?.[INTERACTION]?.eventName !== 'initialPageLoad') interaction = this.ixn = state.prevNode[INTERACTION]
-      else interaction = this.ixn = new Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier)
+      else interaction = this.ixn = new Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef)
       if (!state.currentNode) {
         interaction.checkFinish()
         if (state.depth) setCurrentNode(interaction.root)