@newrelic/browser-agent 1.297.0-rc.1 → 1.297.0-rc.3

package/README.md

@@ -245,6 +245,9 @@ browserAgent.recordCustomEvent(...)
 
 ## Deploying one or more "micro" agents per page
 
+> **ℹ️ Note:**  
+> This loader strategy is slated to be deprecated and eventually removed in a future product release. For better memory usage, build size impacts, entity management and relationships -- a new strategy focused around using a single centralized browser agent instance is actively being worked on. Reach out by email to browser-agent@newrelic.com for more information or if you would like to participate in a limited preview when the feature is ready for early adoption.
+
 The examples above use the `Agent` class at their core, which is ideal for most cases as it will automatically detect page-level events across your web application.
 
 Using the `MicroAgent` class, it is possible to skip the "auto" instrumentation phases of the other loader types, and provide a *very small* agent designed for capturing data in a controlled manner via the API interfaces. The `MicroAgent` captures a distinct `PageView` event when instantiated, and additional `PageAction` and `JavaScriptError` events may be captured by calling the `noticeError` and `addPageAction` methods.

package/dist/cjs/common/constants/agent-constants.js

@@ -3,11 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.MAX_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = exports.DEFAULT_KEY = void 0;
+exports.SESSION_ERROR = exports.MAX_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = exports.DEFAULT_KEY = void 0;
 /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 const IDEAL_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = 16000;
 const MAX_PAYLOAD_SIZE = exports.MAX_PAYLOAD_SIZE = 1000000;
-const DEFAULT_KEY = exports.DEFAULT_KEY = 'NR_CONTAINER_AGENT';
+const DEFAULT_KEY = exports.DEFAULT_KEY = 'NR_CONTAINER_AGENT';
+const SESSION_ERROR = exports.SESSION_ERROR = 'SESSION_ERROR';

package/dist/cjs/common/constants/env.cdn.js

@@ -17,7 +17,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.297.0-rc.1";
+const VERSION = exports.VERSION = "1.297.0-rc.3";
 
 /**
  * Exposes the build type of the agent

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

@@ -17,7 +17,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.297.0-rc.1";
+const VERSION = exports.VERSION = "1.297.0-rc.3";
 
 /**
  * Exposes the build type of the agent

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

@@ -46,8 +46,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.entitled = false;
     /** set at BCS response, stored in runtime */
     this.timeKeeper = undefined;
-    this.recorder = args?.recorder;
-    this.errorNoticed = args?.errorNoticed || false;
+    this.instrumentClass = args;
+    // point this var here just in case it already exists and can be used by APIs (session pause, resume, etc.) before handling rum flags
+    this.recorder = this.instrumentClass?.recorder;
     this.harvestOpts.raw = true;
     this.isSessionTrackingEnabled = (0, _featureGates.canEnableSessionTracking)(agentRef.init) && !!agentRef.runtime.session;
     this.reportSupportabilityMetric('Config/SessionReplay/Enabled');
@@ -67,7 +68,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       // if the mode changed on a different tab, it needs to update this instance to match
       this.mode = agentRef.runtime.session.state.sessionReplayMode;
       if (!this.initialized || this.mode === _constants2.MODE.OFF) return;
-      this.recorder?.startRecording();
+      this.recorder?.startRecording(_constants.TRIGGERS.RESUME, this.mode);
     });
     this.ee.on(_constants2.SESSION_EVENTS.UPDATE, (type, data) => {
       if (!this.recorder || !this.initialized || this.blocked || type !== _constants2.SESSION_EVENT_TYPES.CROSS_TAB) return;
@@ -136,7 +137,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.mode = _constants2.MODE.FULL;
     // if the error was noticed AFTER the recorder was already imported....
     if (this.recorder && this.initialized) {
-      if (!this.agentRef.runtime.isRecording) this.recorder.startRecording();
+      if (!this.agentRef.runtime.isRecording) this.recorder.startRecording(_constants.TRIGGERS.SWITCH_TO_FULL, this.mode); // off --> full
       this.syncWithSessionManager({
         sessionReplayMode: this.mode
       });
@@ -149,9 +150,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
    * Evaluate entitlements and sampling before starting feature mechanics, importing and configuring recording library, and setting storage state
    * @param {boolean} srMode - the true/false state of the "sr" flag (aka. entitlements) from RUM response
    * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
+   * @param {TRIGGERS} [trigger=TRIGGERS.INITIALIZE] - the trigger that initiated the recording.  Usually TRIGGERS.INITIALIZE, but could be TRIGGERS.API since in certain cases that trigger calls this method
    * @returns {void}
    */
-  async initializeRecording(srMode, ignoreSession) {
+  async initializeRecording(srMode, ignoreSession, trigger = _constants.TRIGGERS.INITIALIZE) {
     this.initialized = true;
     if (!this.entitled) return;
 
@@ -166,7 +168,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       timeKeeper
     } = this.agentRef.runtime;
     this.timeKeeper = timeKeeper;
-    if (this.recorder?.parent.trigger === _constants.TRIGGERS.API && this.agentRef.runtime.isRecording) {
+    if (this.recorder?.trigger === _constants.TRIGGERS.API && this.agentRef.runtime.isRecording) {
       this.mode = _constants2.MODE.FULL;
     } else if (!session.isNew && !ignoreSession) {
       // inherit the mode of the existing session
@@ -177,30 +179,25 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     // If off, then don't record (early return)
     if (this.mode === _constants2.MODE.OFF) return;
-    if (!this.recorder) {
-      try {
-        // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
-        const {
-          Recorder
-        } = await Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "recorder" */'../shared/recorder')));
-        this.recorder = new Recorder(this);
-        this.recorder.events.hasError = this.errorNoticed;
-      } catch (err) {
-        return this.abort(_constants.ABORT_REASONS.IMPORT);
-      }
-    } else {
-      this.recorder.parent = this;
+    try {
+      /** will return a recorder instance if already imported, otherwise, will fetch the recorder and initialize it */
+      this.recorder ??= await this.instrumentClass.importRecorder();
+    } catch (err) {
+      /** if the recorder fails to import, abort the feature */
+      return this.abort(_constants.ABORT_REASONS.IMPORT, err);
     }
 
     // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
-    if (this.mode === _constants2.MODE.ERROR && this.errorNoticed) this.mode = _constants2.MODE.FULL;
+    if (this.mode === _constants2.MODE.ERROR && this.instrumentClass.errorNoticed) {
+      this.mode = _constants2.MODE.FULL;
+    }
 
     // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
     // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
     // The makeHarvestPayload should ensure that no payload is returned if we're not in FULL mode...
 
     await this.prepUtils();
-    if (!this.agentRef.runtime.isRecording) this.recorder.startRecording();
+    if (!this.agentRef.runtime.isRecording) this.recorder.startRecording(trigger, this.mode);
     this.syncWithSessionManager({
       sessionReplayMode: this.mode
     });

package/dist/cjs/features/session_replay/constants.js

@@ -61,5 +61,9 @@ const ABORT_REASONS = exports.ABORT_REASONS = {
 /** Reserved room for query param attrs */
 const QUERY_PARAM_PADDING = exports.QUERY_PARAM_PADDING = 5000;
 const TRIGGERS = exports.TRIGGERS = {
-  API: 'api'
+  API: 'api',
+  RESUME: 'resume',
+  SWITCH_TO_FULL: 'switchToFull',
+  INITIALIZE: 'initialize',
+  PRELOAD: 'preload'
 };

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

@@ -20,8 +20,10 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  */
 class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants2.FEATURE_NAME;
-  #mode;
-  #agentRef;
+  /** @type {Promise|undefined} A promise that resolves when the recorder module is imported and added to the class. Undefined if the recorder has never been staged to import with `importRecorder`. */
+  #stagedImport;
+  /** The RRWEB recorder instance, if imported */
+  recorder;
   constructor(agentRef) {
     super(agentRef, _constants2.FEATURE_NAME);
 
@@ -29,7 +31,6 @@ class Instrument extends _instrumentBase.InstrumentBase {
     (0, _recordReplay.setupRecordReplayAPI)(agentRef);
     (0, _pauseReplay.setupPauseReplayAPI)(agentRef);
     let session;
-    this.#agentRef = agentRef;
     try {
       session = JSON.parse(localStorage.getItem("".concat(_constants.PREFIX, "_").concat(_constants.DEFAULT_KEY)));
     } catch (err) {}
@@ -37,15 +38,16 @@ class Instrument extends _instrumentBase.InstrumentBase {
       this.ee.on(_constants2.SR_EVENT_EMITTER_TYPES.RECORD, () => this.#apiStartOrRestartReplay());
     }
     if (this.#canPreloadRecorder(session)) {
-      this.#mode = session?.sessionReplayMode;
-      this.#preloadStartRecording();
-    } else {
-      this.importAggregator(this.#agentRef, () => Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "session_replay-aggregate" */'../aggregate'))));
+      this.importRecorder().then(recorder => {
+        recorder.startRecording(_constants2.TRIGGERS.PRELOAD, session?.sessionReplayMode);
+      }); // could handle specific fail-state behaviors with a .catch block here
     }
+    this.importAggregator(this.agentRef, () => Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "session_replay-aggregate" */'../aggregate'))), this);
 
     /** If the recorder is running, we can pass error events on to the agg to help it switch to full mode later */
     this.ee.on('err', e => {
-      if (this.#agentRef.runtime.isRecording) {
+      if (this.blocked) return;
+      if (this.agentRef.runtime.isRecording) {
         this.errorNoticed = true;
         (0, _handle.handle)(_constants2.SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, [e], undefined, this.featureName, this.ee);
       }
@@ -58,66 +60,50 @@ class Instrument extends _instrumentBase.InstrumentBase {
       // this might be a new session if entity initializes: conservatively start recording if first-time config allows
       // Note: users with SR enabled, as well as these other configs enabled by-default, will be penalized by the recorder overhead EVEN IF they don't actually have or get
       // entitlement or sampling decision, or otherwise intentionally opted-in for the feature.
-      return (0, _utils.isPreloadAllowed)(this.#agentRef.init);
+      return (0, _utils.isPreloadAllowed)(this.agentRef.init);
     } else if (session.sessionReplayMode === _constants.MODE.FULL || session.sessionReplayMode === _constants.MODE.ERROR) {
       return true; // existing sessions get to continue recording, regardless of this page's configs or if it has expired (conservatively)
     } else {
       // SR mode was OFF but may potentially be turned on if session resets and configs allows the new session to have replay...
-      return (0, _utils.isPreloadAllowed)(this.#agentRef.init);
+      return (0, _utils.isPreloadAllowed)(this.agentRef.init);
     }
   }
-  #alreadyStarted = false;
+
   /**
-   * This func is use for early pre-load recording prior to replay feature (agg) being loaded onto the page. It should only setup once, including if already called and in-progress.
+   * Returns a promise that imports the recorder module. Only lets the recorder module be imported and instantiated once. Rejects if failed to import/instantiate.
+   * @returns {Promise}
    */
-  async #preloadStartRecording(trigger) {
-    if (this.#alreadyStarted) return;
-    this.#alreadyStarted = true;
-    try {
-      const {
-        Recorder
-      } = await Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "recorder" */'../shared/recorder')));
-
-      // If startReplay() has been used by this point, we must record in full mode regardless of session preload:
-      // Note: recorder starts here with w/e the mode is at this time, but this may be changed later (see #apiStartOrRestartReplay else-case)
-      this.recorder ??= new Recorder({
-        ...this,
-        mode: this.#mode,
-        agentRef: this.#agentRef,
-        trigger,
-        timeKeeper: this.#agentRef.runtime.timeKeeper
-      }); // if TK exists due to deferred state, pass it
-      this.recorder.startRecording();
-      this.abortHandler = this.recorder.stopRecording;
-    } catch (err) {
-      this.parent.ee.emit('internal-error', [err]);
-    }
-    this.importAggregator(this.#agentRef, () => Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "session_replay-aggregate" */'../aggregate'))), {
-      recorder: this.recorder,
-      errorNoticed: this.errorNoticed
+  importRecorder() {
+    /** if we already have a recorder fully set up, just return it */
+    if (this.recorder) return Promise.resolve(this.recorder);
+    /** conditional -- if we have never started importing, stage the import and store it in state */
+    this.#stagedImport ??= Promise.resolve().then(() => _interopRequireWildcard(require(/* webpackChunkName: "recorder" */'../shared/recorder'))).then(({
+      Recorder
+    }) => {
+      this.recorder = new Recorder(this);
+      /** return the recorder for promise chaining */
+      return this.recorder;
+    }).catch(err => {
+      this.ee.emit('internal-error', [err]);
+      this.blocked = true;
+      /** return the err for promise chaining */
+      throw err;
     });
+    return this.#stagedImport;
   }
 
   /**
    * Called whenever startReplay API is used. That could occur any time, pre or post load.
    */
   #apiStartOrRestartReplay() {
+    if (this.blocked) return;
     if (this.featAggregate) {
       // post-load; there's possibly already an ongoing recording
-      if (this.featAggregate.mode !== _constants.MODE.FULL) this.featAggregate.initializeRecording(_constants.MODE.FULL, true);
+      if (this.featAggregate.mode !== _constants.MODE.FULL) this.featAggregate.initializeRecording(_constants.MODE.FULL, true, _constants2.TRIGGERS.API);
     } else {
-      // pre-load
-      this.#mode = _constants.MODE.FULL;
-      this.#preloadStartRecording(_constants2.TRIGGERS.API);
-      // There's a race here wherein either:
-      // a. Recorder has not been initialized, and we've set the enforced mode, so we're good, or;
-      // b. Record has been initialized, possibly with the "wrong" mode, so we have to correct that + restart.
-      if (this.recorder && this.recorder.parent.mode !== _constants.MODE.FULL) {
-        this.recorder.parent.mode = _constants.MODE.FULL;
-        this.recorder.stopRecording();
-        this.recorder.startRecording();
-        this.abortHandler = this.recorder.stopRecording;
-      }
+      this.importRecorder().then(() => {
+        this.recorder.startRecording(_constants2.TRIGGERS.API, _constants.MODE.FULL);
+      }); // could handle specific fail-state behaviors with a .catch block here
     }
   }
 }

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

@@ -29,11 +29,19 @@ class Recorder {
   #fixing = false;
   #warnCSSOnce = (0, _invoke.single)(() => (0, _console.warn)(47)); // notifies user of potential replayer issue if fix_stylesheets is off
 
-  constructor(parent) {
-    /** The parent class that instantiated the recorder */
-    this.parent = parent;
+  #canRecord = true;
+  triggerHistory = []; // useful for debugging
+
+  constructor(srInstrument) {
+    /** The parent classes that share the recorder */
+    this.srInstrument = srInstrument;
+    // --- shortcuts
+    this.ee = srInstrument.ee;
+    this.srFeatureName = srInstrument.featureName;
+    this.agentRef = srInstrument.agentRef;
+    this.isErrorMode = false;
     /** 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;
+    this.shouldFix = this.agentRef.init.session_replay.fix_stylesheets;
 
     /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
     this.events = new _recorderEvents.RecorderEvents(this.shouldFix);
@@ -45,11 +53,18 @@ class Recorder {
     this.lastMeta = false;
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
     this.stopRecording = () => {
-      this.parent.agentRef.runtime.isRecording = false;
+      this.agentRef.runtime.isRecording = false;
     };
+    (0, _registerHandler.registerHandler)(_agentConstants.SESSION_ERROR, () => {
+      this.#canRecord = false;
+      this.stopRecording();
+    }, this.srFeatureName, this.ee);
     (0, _registerHandler.registerHandler)(RRWEB_DATA_CHANNEL, (event, isCheckout) => {
       this.audit(event, isCheckout);
-    }, this.parent.featureName, this.parent.ee);
+    }, this.srFeatureName, this.ee);
+  }
+  get trigger() {
+    return this.triggerHistory[this.triggerHistory.length - 1];
   }
   getEvents() {
     return {
@@ -66,13 +81,20 @@ class Recorder {
 
   /** Clears the buffer (this.events), and resets all payload metadata properties */
   clearBuffer() {
-    this.backloggedEvents = this.parent.mode === _constants2.MODE.ERROR ? this.events : new _recorderEvents.RecorderEvents(this.shouldFix);
+    this.backloggedEvents = this.isErrorMode ? this.events : new _recorderEvents.RecorderEvents(this.shouldFix);
     this.events = new _recorderEvents.RecorderEvents(this.shouldFix);
   }
 
   /** Begin recording using configured recording lib */
-  startRecording() {
-    this.parent.agentRef.runtime.isRecording = true;
+  startRecording(trigger, mode) {
+    if (!this.#canRecord) return;
+    this.triggerHistory.push(trigger); // keep track of all triggers, useful for lifecycle debugging.  "this.trigger" returns the latest entry
+
+    this.isErrorMode = mode === _constants2.MODE.ERROR;
+
+    /** if the recorder is already recording... lets stop it before starting a new one */
+    this.stopRecording();
+    this.agentRef.runtime.isRecording = true;
     const {
       block_class,
       ignore_class,
@@ -83,7 +105,7 @@ class Recorder {
       mask_all_inputs,
       inline_images,
       collect_fonts
-    } = this.parent.agentRef.init.session_replay;
+    } = this.agentRef.init.session_replay;
 
     // set up rrweb configurations for maximum privacy --
     // https://newrelic.atlassian.net/wiki/spaces/O11Y/pages/2792293280/2023+02+28+Browser+-+Session+Replay#Configuration-options
@@ -91,7 +113,7 @@ class Recorder {
     try {
       stop = (0, _rrweb.record)({
         emit: (event, isCheckout) => {
-          (0, _handle.handle)(RRWEB_DATA_CHANNEL, [event, isCheckout], undefined, this.parent.featureName, this.parent.ee);
+          (0, _handle.handle)(RRWEB_DATA_CHANNEL, [event, isCheckout], undefined, this.srFeatureName, this.ee);
         },
         blockClass: block_class,
         ignoreClass: ignore_class,
@@ -105,14 +127,14 @@ class Recorder {
         inlineStylesheet: true,
         inlineImages: inline_images,
         collectFonts: collect_fonts,
-        checkoutEveryNms: _constants.CHECKOUT_MS[this.parent.mode],
+        checkoutEveryNms: _constants.CHECKOUT_MS[mode],
         recordAfter: 'DOMContentLoaded'
       });
     } catch (err) {
-      this.parent.ee.emit('internal-error', [err]);
+      this.ee.emit('internal-error', [err]);
     }
     this.stopRecording = () => {
-      this.parent.agentRef.runtime.isRecording = false;
+      this.agentRef.runtime.isRecording = false;
       stop?.();
     };
   }
@@ -125,14 +147,14 @@ class Recorder {
    */
   audit(event, isCheckout) {
     /** An count of stylesheet objects that were blocked from accessing contents via JS */
-    const incompletes = this.parent.agentRef.init.session_replay.fix_stylesheets ? _stylesheetEvaluator.stylesheetEvaluator.evaluate() : 0;
+    const incompletes = this.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) {
       if (incompletes > 0) {
         this.events.inlinedAllStylesheets = false;
         this.#warnCSSOnce();
-        (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Skipped', incompletes], undefined, _features.FEATURE_NAMES.metrics, this.parent.ee);
+        (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Skipped', incompletes], undefined, _features.FEATURE_NAMES.metrics, this.ee);
       }
       return this.store(event, isCheckout);
     }
@@ -145,8 +167,8 @@ class Recorder {
           this.events.inlinedAllStylesheets = false;
           this.shouldFix = false;
         }
-        (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Failed', failedToFix], undefined, _features.FEATURE_NAMES.metrics, this.parent.ee);
-        (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Fixed', incompletes - failedToFix], undefined, _features.FEATURE_NAMES.metrics, this.parent.ee);
+        (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Failed', failedToFix], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+        (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Fixed', incompletes - failedToFix], undefined, _features.FEATURE_NAMES.metrics, this.ee);
         this.takeFullSnapshot();
       });
       /** Only start ignoring data if got a faulty snapshot */
@@ -158,10 +180,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 || this.parent.blocked) return;
+    if (!event || this.srInstrument.featAggregate?.blocked) return;
 
     /** because we've waited until draining to process the buffered rrweb events, we can guarantee the timekeeper exists */
-    event.timestamp = this.parent.timeKeeper.correctAbsoluteTimestamp(event.timestamp);
+    event.timestamp = this.agentRef.runtime.timeKeeper.correctAbsoluteTimestamp(event.timestamp);
     event.__serialized = (0, _stringify.stringify)(event);
     const eventBytes = event.__serialized.length;
     /** The estimated size of the payload after compression */
@@ -170,7 +192,7 @@ class Recorder {
     // to help reconstruct the replay later and must be included.  While waiting and buffering for errors to come through,
     // each time we see a new checkout, we can drop the old data.
     // we need to check for meta because rrweb will flag it as checkout twice, once for meta, then once for snapshot
-    if (this.parent.mode === _constants2.MODE.ERROR && isCheckout && event.type === _constants.RRWEB_EVENT_TYPES.Meta) {
+    if (this.isErrorMode && isCheckout && event.type === _constants.RRWEB_EVENT_TYPES.Meta) {
       // we are still waiting for an error to throw, so keep wiping the buffer over time
       this.clearBuffer();
     }
@@ -185,16 +207,16 @@ class Recorder {
 
     // We are making an effort to try to keep payloads manageable for unloading.  If they reach the unload limit before their interval,
     // it will send immediately.  This often happens on the first snapshot, which can be significantly larger than the other payloads.
-    if ((this.events.hasSnapshot && this.events.hasMeta || payloadSize > _agentConstants.IDEAL_PAYLOAD_SIZE) && this.parent.mode === _constants2.MODE.FULL) {
+    if ((this.events.hasSnapshot && this.events.hasMeta || payloadSize > _agentConstants.IDEAL_PAYLOAD_SIZE) && !this.isErrorMode) {
       // if we've made it to the ideal size of ~16kb before the interval timer, we should send early.
-      this.parent.agentRef.runtime.harvester.triggerHarvestFor(this.parent);
+      this.agentRef.runtime.harvester.triggerHarvestFor(this.srInstrument.featAggregate);
     }
   }
 
   /** force the recording lib to take a full DOM snapshot.  This needs to occur in certain cases, like visibility changes */
   takeFullSnapshot() {
     try {
-      if (!this.parent.agentRef.runtime.isRecording) return;
+      if (!this.agentRef.runtime.isRecording) return;
       _rrweb.record.takeFullSnapshot();
     } catch (err) {
       // in the off chance we think we are recording, but rrweb does not, rrweb's lib will throw an error.  This catch is just a precaution
@@ -215,7 +237,7 @@ class Recorder {
    * https://staging.onenr.io/037jbJWxbjy
    * */
   estimateCompression(data) {
-    if (!!this.parent.gzipper && !!this.parent.u8) return data * _constants.AVG_COMPRESSION;
+    if (!!this.srInstrument.featAggregate?.gzipper && !!this.srInstrument.featAggregate?.u8) return data * _constants.AVG_COMPRESSION;
     return data;
   }
 }

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

@@ -13,6 +13,8 @@ var _features = require("../../loaders/features/features");
 var _utils = require("../session_replay/shared/utils");
 var _featureGates = require("./feature-gates");
 var _invoke = require("../../common/util/invoke");
+var _agentConstants = require("../../common/constants/agent-constants");
+var _handle = require("../../common/event-emitter/handle");
 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; } /**
  * Copyright 2020-2025 New Relic, Inc. All rights reserved.
@@ -34,6 +36,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
    */
   constructor(agentRef, featureName) {
     super(agentRef.agentIdentifier, featureName);
+    this.agentRef = agentRef;
 
     /** @type {Function | undefined} This should be set by any derived Instrument class if it has things to do when feature fails or is killed. */
     this.abortHandler = undefined;
@@ -76,7 +79,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
    * @param {Object} agentRef - reference to the base agent ancestor that this feature belongs to
    * @param {Function} fetchAggregator - a function that returns a promise that resolves to the aggregate module
    * @param {Object} [argsObjFromInstrument] - any values or references to pass down to aggregate
-   * @returns void
+   * @returns
    */
   importAggregator(agentRef, fetchAggregator, argsObjFromInstrument = {}) {
     if (this.featAggregate) return;
@@ -101,7 +104,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
       } catch (e) {
         (0, _console.warn)(20, e);
         this.ee.emit('internal-error', [e]);
-        if (this.featureName === _features.FEATURE_NAMES.sessionReplay) this.abortHandler?.(); // SR should stop recording if session DNE
+        (0, _handle.handle)(_agentConstants.SESSION_ERROR, [e], undefined, this.featureName, this.ee);
       }
 
       /**
@@ -142,6 +145,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
   * @returns
   */
   #shouldImportAgg(featureName, session, agentInit) {
+    if (this.blocked) return false;
     switch (featureName) {
       case _features.FEATURE_NAMES.sessionReplay:
         // the session manager must be initialized successfully for Replay & Trace features

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

@@ -33,10 +33,13 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 const nonAutoFeatures = [_features.FEATURE_NAMES.jserrors, _features.FEATURE_NAMES.genericEvents, _features.FEATURE_NAMES.metrics, _features.FEATURE_NAMES.logging];
 
 /**
- * @deprecated This feature has been deprecated and will be removed in a future release. A future product centralizing around a single agent instance will be released as a replacement, at which time this loader will be removed.
- * --- A minimal agent class designed to only respond to manual user input. As such, this class does not
+ * A minimal agent class designed to only respond to manual user input. As such, this class does not
  * automatically instrument. Instead, each MicroAgent instance will lazy load the required features and can support loading multiple instances on one page.
  * Out of the box, it can manually handle and report Page View, Page Action, and Error events.
+ *
+ * @note This loader strategy is slated to be deprecated and eventually removed in a future product release. For better memory usage, build size impacts, entity management and relationships -- a new strategy focused around using a single centralized browser agent instance is actively being worked on. Reach out by email to browser-agent@newrelic.com for more information or if you would like to participate in a limited preview when the feature is ready for early adoption.
+ *
+ * @see {@link https://www.npmjs.com/package/@newrelic/browser-agent#deploying-one-or-more-micro-agents-per-page} for more information in the documentation.
  */
 class MicroAgent extends _microAgentBase.MicroAgentBase {
   /**

package/dist/esm/common/constants/agent-constants.js

@@ -4,4 +4,5 @@
  */
 export const IDEAL_PAYLOAD_SIZE = 16000;
 export const MAX_PAYLOAD_SIZE = 1000000;
-export const DEFAULT_KEY = 'NR_CONTAINER_AGENT';
+export const DEFAULT_KEY = 'NR_CONTAINER_AGENT';
+export const SESSION_ERROR = 'SESSION_ERROR';

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.297.0-rc.1";
+export const VERSION = "1.297.0-rc.3";
 
 /**
  * Exposes the build type of the agent

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

@@ -11,7 +11,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.297.0-rc.1";
+export const VERSION = "1.297.0-rc.3";
 
 /**
  * Exposes the build type of the agent