@newrelic/browser-agent 1.297.0 → 1.297.1-rc.0

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

@@ -41,8 +41,9 @@ export class Aggregate extends 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 = canEnableSessionTracking(agentRef.init) && !!agentRef.runtime.session;
     this.reportSupportabilityMetric('Config/SessionReplay/Enabled');
@@ -62,7 +63,7 @@ export class Aggregate extends 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 === MODE.OFF) return;
-      this.recorder?.startRecording();
+      this.recorder?.startRecording(TRIGGERS.RESUME, this.mode);
     });
     this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
       if (!this.recorder || !this.initialized || this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return;
@@ -131,7 +132,7 @@ export class Aggregate extends AggregateBase {
     this.mode = 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(TRIGGERS.SWITCH_TO_FULL, this.mode); // off --> full
       this.syncWithSessionManager({
         sessionReplayMode: this.mode
       });
@@ -144,9 +145,10 @@ export class Aggregate extends 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 = TRIGGERS.INITIALIZE) {
     this.initialized = true;
     if (!this.entitled) return;
 
@@ -161,7 +163,7 @@ export class Aggregate extends AggregateBase {
       timeKeeper
     } = this.agentRef.runtime;
     this.timeKeeper = timeKeeper;
-    if (this.recorder?.parent.trigger === TRIGGERS.API && this.agentRef.runtime.isRecording) {
+    if (this.recorder?.trigger === TRIGGERS.API && this.agentRef.runtime.isRecording) {
       this.mode = MODE.FULL;
     } else if (!session.isNew && !ignoreSession) {
       // inherit the mode of the existing session
@@ -172,30 +174,25 @@ export class Aggregate extends AggregateBase {
     }
     // If off, then don't record (early return)
     if (this.mode === MODE.OFF) return;
-    if (!this.recorder) {
-      try {
-        // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
-        const {
-          Recorder
-        } = await import(/* webpackChunkName: "recorder" */'../shared/recorder');
-        this.recorder = new Recorder(this);
-        this.recorder.events.hasError = this.errorNoticed;
-      } catch (err) {
-        return this.abort(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(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 === MODE.ERROR && this.errorNoticed) this.mode = MODE.FULL;
+    if (this.mode === MODE.ERROR && this.instrumentClass.errorNoticed) {
+      this.mode = 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/esm/features/session_replay/constants.js

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

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

@@ -15,8 +15,10 @@ import { setupRecordReplayAPI } from '../../../loaders/api/recordReplay';
 import { setupPauseReplayAPI } from '../../../loaders/api/pauseReplay';
 export class Instrument extends InstrumentBase {
   static featureName = 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, FEATURE_NAME);
 
@@ -24,7 +26,6 @@ export class Instrument extends InstrumentBase {
     setupRecordReplayAPI(agentRef);
     setupPauseReplayAPI(agentRef);
     let session;
-    this.#agentRef = agentRef;
     try {
       session = JSON.parse(localStorage.getItem("".concat(PREFIX, "_").concat(DEFAULT_KEY)));
     } catch (err) {}
@@ -32,15 +33,16 @@ export class Instrument extends InstrumentBase {
       this.ee.on(SR_EVENT_EMITTER_TYPES.RECORD, () => this.#apiStartOrRestartReplay());
     }
     if (this.#canPreloadRecorder(session)) {
-      this.#mode = session?.sessionReplayMode;
-      this.#preloadStartRecording();
-    } else {
-      this.importAggregator(this.#agentRef, () => import(/* webpackChunkName: "session_replay-aggregate" */'../aggregate'));
+      this.importRecorder().then(recorder => {
+        recorder.startRecording(TRIGGERS.PRELOAD, session?.sessionReplayMode);
+      }); // could handle specific fail-state behaviors with a .catch block here
     }
+    this.importAggregator(this.agentRef, () => import(/* 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;
         handle(SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, [e], undefined, this.featureName, this.ee);
       }
@@ -53,66 +55,50 @@ export class Instrument extends 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 isPreloadAllowed(this.#agentRef.init);
+      return isPreloadAllowed(this.agentRef.init);
     } else if (session.sessionReplayMode === MODE.FULL || session.sessionReplayMode === 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 isPreloadAllowed(this.#agentRef.init);
+      return 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 import(/* 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, () => import(/* 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 ??= import(/* 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 !== MODE.FULL) this.featAggregate.initializeRecording(MODE.FULL, true);
+      if (this.featAggregate.mode !== MODE.FULL) this.featAggregate.initializeRecording(MODE.FULL, true, TRIGGERS.API);
     } else {
-      // pre-load
-      this.#mode = MODE.FULL;
-      this.#preloadStartRecording(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 !== MODE.FULL) {
-        this.recorder.parent.mode = MODE.FULL;
-        this.recorder.stopRecording();
-        this.recorder.startRecording();
-        this.abortHandler = this.recorder.stopRecording;
-      }
+      this.importRecorder().then(() => {
+        this.recorder.startRecording(TRIGGERS.API, MODE.FULL);
+      }); // could handle specific fail-state behaviors with a .catch block here
     }
   }
 }

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

@@ -12,7 +12,7 @@ import { handle } from '../../../common/event-emitter/handle';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { customMasker } from './utils';
-import { IDEAL_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
+import { IDEAL_PAYLOAD_SIZE, SESSION_ERROR } from '../../../common/constants/agent-constants';
 import { warn } from '../../../common/util/console';
 import { single } from '../../../common/util/invoke';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
@@ -22,11 +22,19 @@ export class Recorder {
   #fixing = false;
   #warnCSSOnce = single(() => 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(this.shouldFix);
@@ -38,11 +46,18 @@ export 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;
     };
+    registerHandler(SESSION_ERROR, () => {
+      this.#canRecord = false;
+      this.stopRecording();
+    }, this.srFeatureName, this.ee);
     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 {
@@ -59,13 +74,20 @@ export class Recorder {
 
   /** Clears the buffer (this.events), and resets all payload metadata properties */
   clearBuffer() {
-    this.backloggedEvents = this.parent.mode === MODE.ERROR ? this.events : new RecorderEvents(this.shouldFix);
+    this.backloggedEvents = this.isErrorMode ? this.events : new RecorderEvents(this.shouldFix);
     this.events = new 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 === 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,
@@ -76,7 +98,7 @@ export 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
@@ -84,7 +106,7 @@ export class Recorder {
     try {
       stop = recorder({
         emit: (event, isCheckout) => {
-          handle(RRWEB_DATA_CHANNEL, [event, isCheckout], undefined, this.parent.featureName, this.parent.ee);
+          handle(RRWEB_DATA_CHANNEL, [event, isCheckout], undefined, this.srFeatureName, this.ee);
         },
         blockClass: block_class,
         ignoreClass: ignore_class,
@@ -98,14 +120,14 @@ export class Recorder {
         inlineStylesheet: true,
         inlineImages: inline_images,
         collectFonts: collect_fonts,
-        checkoutEveryNms: CHECKOUT_MS[this.parent.mode],
+        checkoutEveryNms: 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?.();
     };
   }
@@ -118,14 +140,14 @@ export 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.evaluate() : 0;
+    const incompletes = this.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) {
       if (incompletes > 0) {
         this.events.inlinedAllStylesheets = false;
         this.#warnCSSOnce();
-        handle(SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Skipped', incompletes], undefined, FEATURE_NAMES.metrics, this.parent.ee);
+        handle(SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Skipped', incompletes], undefined, FEATURE_NAMES.metrics, this.ee);
       }
       return this.store(event, isCheckout);
     }
@@ -138,8 +160,8 @@ export class Recorder {
           this.events.inlinedAllStylesheets = false;
           this.shouldFix = false;
         }
-        handle(SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Failed', failedToFix], undefined, FEATURE_NAMES.metrics, this.parent.ee);
-        handle(SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Fixed', incompletes - failedToFix], undefined, FEATURE_NAMES.metrics, this.parent.ee);
+        handle(SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Failed', failedToFix], undefined, FEATURE_NAMES.metrics, this.ee);
+        handle(SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Fixed', incompletes - failedToFix], undefined, FEATURE_NAMES.metrics, this.ee);
         this.takeFullSnapshot();
       });
       /** Only start ignoring data if got a faulty snapshot */
@@ -151,10 +173,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 || 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 = stringify(event);
     const eventBytes = event.__serialized.length;
     /** The estimated size of the payload after compression */
@@ -163,7 +185,7 @@ export 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 === MODE.ERROR && isCheckout && event.type === RRWEB_EVENT_TYPES.Meta) {
+    if (this.isErrorMode && isCheckout && event.type === RRWEB_EVENT_TYPES.Meta) {
       // we are still waiting for an error to throw, so keep wiping the buffer over time
       this.clearBuffer();
     }
@@ -178,16 +200,16 @@ export 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 > IDEAL_PAYLOAD_SIZE) && this.parent.mode === MODE.FULL) {
+    if ((this.events.hasSnapshot && this.events.hasMeta || payloadSize > 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;
       recorder.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
@@ -208,7 +230,7 @@ export class Recorder {
    * https://staging.onenr.io/037jbJWxbjy
    * */
   estimateCompression(data) {
-    if (!!this.parent.gzipper && !!this.parent.u8) return data * AVG_COMPRESSION;
+    if (!!this.srInstrument.featAggregate?.gzipper && !!this.srInstrument.featAggregate?.u8) return data * AVG_COMPRESSION;
     return data;
   }
 }

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

@@ -18,6 +18,8 @@ import { FEATURE_NAMES } from '../../loaders/features/features';
 import { hasReplayPrerequisite } from '../session_replay/shared/utils';
 import { canEnableSessionTracking } from './feature-gates';
 import { single } from '../../common/util/invoke';
+import { SESSION_ERROR } from '../../common/constants/agent-constants';
+import { handle } from '../../common/event-emitter/handle';
 
 /**
  * Base class for instrumenting a feature.
@@ -31,6 +33,7 @@ export class InstrumentBase extends 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;
@@ -73,7 +76,7 @@ export class InstrumentBase extends 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;
@@ -98,7 +101,7 @@ export class InstrumentBase extends FeatureBase {
       } catch (e) {
         warn(20, e);
         this.ee.emit('internal-error', [e]);
-        if (this.featureName === FEATURE_NAMES.sessionReplay) this.abortHandler?.(); // SR should stop recording if session DNE
+        handle(SESSION_ERROR, [e], undefined, this.featureName, this.ee);
       }
 
       /**
@@ -139,6 +142,7 @@ export class InstrumentBase extends FeatureBase {
   * @returns
   */
   #shouldImportAgg(featureName, session, agentInit) {
+    if (this.blocked) return false;
     switch (featureName) {
       case FEATURE_NAMES.sessionReplay:
         // the session manager must be initialized successfully for Replay & Trace features

package/dist/esm/loaders/api/interaction-types.js

@@ -86,5 +86,4 @@
  * @returns {InteractionInstance} Returns the same interaction object allowing method chaining.
  */
 
-/* istanbul ignore next */
 export const unused = {};

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

@@ -28,10 +28,13 @@ import { setupWrapLoggerAPI } from './api/wrapLogger';
 const nonAutoFeatures = [FEATURE_NAMES.jserrors, FEATURE_NAMES.genericEvents, FEATURE_NAMES.metrics, 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.
  */
 export class MicroAgent extends MicroAgentBase {
   /**

package/dist/types/common/constants/agent-constants.d.ts

@@ -5,4 +5,5 @@
 export const IDEAL_PAYLOAD_SIZE: 16000;
 export const MAX_PAYLOAD_SIZE: 1000000;
 export const DEFAULT_KEY: "NR_CONTAINER_AGENT";
+export const SESSION_ERROR: "SESSION_ERROR";
 //# sourceMappingURL=agent-constants.d.ts.map

package/dist/types/common/constants/agent-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-constants.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/agent-constants.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,iCAAkC,KAAK,CAAA;AACvC,+BAAgC,OAAO,CAAA;AACvC,0BAA2B,oBAAoB,CAAA"}
+{"version":3,"file":"agent-constants.d.ts","sourceRoot":"","sources":["../../../../src/common/constants/agent-constants.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,iCAAkC,KAAK,CAAA;AACvC,+BAAgC,OAAO,CAAA;AACvC,0BAA2B,oBAAoB,CAAA;AAC/C,4BAA6B,eAAe,CAAA"}

package/dist/types/common/harvest/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/types.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;;;GAIG;AAEH;;;;;;;;;;GAUG;AAGH,wBAAwB;wCAtBX,KAAK,GAAC,UAAU,GAAC,QAAQ,GAAC,KAAK,GAAC,WAAW,GAAC,MAAM;;;;;QAKjD,MAAM;;;;UACN,MAAM;;;;;;cAKN,yBAAyB;;;;aACzB,cAAc;;;;eAEzB;QAA8B,YAAY,EAA/B,OAAO;QACY,cAAc,EAAjC,OAAO;QACY,aAAa,EAAhC,OAAO;QACY,YAAY,EAA/B,OAAO;KAClB;;;;kBAAW,OAAO,wBAAwB,EAAE,cAAc"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/types.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;;;GAIG;AAEH;;;;;;;;;;GAUG;AAEH,wBAAwB;wCArBX,KAAK,GAAC,UAAU,GAAC,QAAQ,GAAC,KAAK,GAAC,WAAW,GAAC,MAAM;;;;;QAKjD,MAAM;;;;UACN,MAAM;;;;;;cAKN,yBAAyB;;;;aACzB,cAAc;;;;eAEzB;QAA8B,YAAY,EAA/B,OAAO;QACY,cAAc,EAAjC,OAAO;QACY,aAAa,EAAhC,OAAO;QACY,YAAY,EAA/B,OAAO;KAClB;;;;kBAAW,OAAO,wBAAwB,EAAE,cAAc"}

package/dist/types/features/session_replay/aggregate/index.d.ts

@@ -12,8 +12,8 @@ export class Aggregate extends AggregateBase {
     entitled: boolean;
     /** set at BCS response, stored in runtime */
     timeKeeper: any;
+    instrumentClass: any;
     recorder: any;
-    errorNoticed: any;
     isSessionTrackingEnabled: boolean;
     replayIsActive(): boolean;
     handleError(e: any): void;
@@ -22,9 +22,16 @@ export class Aggregate extends 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}
      */
-    initializeRecording(srMode: boolean, ignoreSession: boolean): void;
+    initializeRecording(srMode: boolean, ignoreSession: boolean, trigger?: {
+        API: string;
+        RESUME: string;
+        SWITCH_TO_FULL: string;
+        INITIALIZE: string;
+        PRELOAD: string;
+    }): void;
     prepUtils(): Promise<void>;
     makeHarvestPayload(shouldRetryOnFail: any): {
         targetApp: undefined;

package/dist/types/features/session_replay/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AAwBA;IACE,2BAAiC;IAIjC,sCAqFC;IAxFD,aAAe;IAKb,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAEnB,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IAC9B,kBAA+C;IAG/C,kCAAqG;IAmEvG,0BAEC;IAED,0BAMC;IAED,qBAUC;IAED;;;;;OAKG;IACH,4BAJW,OAAO,iBACP,OAAO,GACL,IAAI,CAkDhB;IAED,2BASC;IAED;;;oBAyCC;IAED;;;;OAIG;IACH,6BAHW,MAAM,EAAE,GACN;QAAE,UAAU,EAAE,MAAM,GAAC,SAAS,CAAC;QAAC,SAAS,EAAE,MAAM,GAAC,SAAS,CAAA;KAAE,CAUzE;IAED;;;;;;;;;;MAsEC;IAED,sCAKC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,+CASC;IAED,yCAIC;CACF;8BA3W6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AAwBA;IACE,2BAAiC;IAIjC,sCAuFC;IA1FD,aAAe;IAKb,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAEnB,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,qBAA2B;IAE3B,cAA8C;IAI9C,kCAAqG;IAmEvG,0BAEC;IAED,0BAMC;IAED,qBAUC;IAED;;;;;;OAMG;IACH,4BALW,OAAO,iBACP,OAAO;;;;;;QAEL,IAAI,CA8ChB;IAED,2BASC;IAED;;;oBAyCC;IAED;;;;OAIG;IACH,6BAHW,MAAM,EAAE,GACN;QAAE,UAAU,EAAE,MAAM,GAAC,SAAS,CAAC;QAAC,SAAS,EAAE,MAAM,GAAC,SAAS,CAAA;KAAE,CAUzE;IAED;;;;;;;;;;MAsEC;IAED,sCAKC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,+CASC;IAED,yCAIC;CACF;8BA1W6B,4BAA4B"}

package/dist/types/features/session_replay/constants.d.ts

@@ -57,5 +57,9 @@ export namespace ABORT_REASONS {
 export const QUERY_PARAM_PADDING: 5000;
 export namespace TRIGGERS {
     let API: string;
+    let RESUME: string;
+    let SWITCH_TO_FULL: string;
+    let INITIALIZE: string;
+    let PRELOAD: string;
 }
 //# sourceMappingURL=constants.d.ts.map

package/dist/types/features/session_replay/instrument/index.d.ts

@@ -1,7 +1,14 @@
 export class Instrument extends InstrumentBase {
     static featureName: string;
     constructor(agentRef: any);
+    /** The RRWEB recorder instance, if imported */
+    recorder: any;
     errorNoticed: boolean;
+    /**
+     * 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}
+     */
+    importRecorder(): Promise<any>;
     #private;
 }
 export const SessionReplay: typeof Instrument;

package/dist/types/features/session_replay/instrument/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/instrument/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IAIjC,2BA+BC;IAJK,sBAAwB;;CA6D/B;AAED,8CAAuC;+BArGR,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/instrument/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IAMjC,2BAgCC;IAnCD,+CAA+C;IAC/C,cAAQ;IA8BF,sBAAwB;IAmB9B;;;OAGG;IACH,+BAkBC;;CAgBF;AAED,8CAAuC;+BApGR,6BAA6B"}

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

@@ -1,7 +1,12 @@
 export class Recorder {
-    constructor(parent: any);
-    /** The parent class that instantiated the recorder */
-    parent: any;
+    constructor(srInstrument: any);
+    triggerHistory: any[];
+    /** The parent classes that share the recorder */
+    srInstrument: any;
+    ee: any;
+    srFeatureName: any;
+    agentRef: any;
+    isErrorMode: boolean;
     /** A flag that can be set to false by failing conversions to stop the fetching process */
     shouldFix: any;
     /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
@@ -14,6 +19,7 @@ export class Recorder {
     lastMeta: boolean;
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
     stopRecording: () => void;
+    get trigger(): any;
     getEvents(): {
         events: any[];
         type: string;
@@ -27,7 +33,7 @@ export class Recorder {
     /** Clears the buffer (this.events), and resets all payload metadata properties */
     clearBuffer(): void;
     /** Begin recording using configured recording lib */
-    startRecording(): void;
+    startRecording(trigger: any, mode: any): void;
     /**
      * audit - Checks if the event node payload is missing certain attributes
      * will forward on to the "store" method if nothing needs async fixing

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

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAqBA;IAME,yBAkBC;IAjBC,sDAAsD;IACtD,YAAoB;IACpB,0FAA0F;IAC1F,eAAyE;IAEzE,iHAAiH;IACjH,uBAAgD;IAChD,mFAAmF;IACnF,iCAA0D;IAC1D,uIAAuI;IACvI,yBAA4B;IAC5B,kIAAkI;IAClI,kBAAqB;IACrB,uIAAuI;IACvI,0BAA+E;IAKjF;;;;;;;;;MAWC;IAED,kFAAkF;IAClF,oBAGC;IAED,qDAAqD;IACrD,uBAiCC;IAED;;;;;OAKG;IACH,aAHW,GAAC,cACD,GAAC,QAiCX;IAED,yHAAyH;IACzH,yCAgCC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BArM8B,mBAAmB"}
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAqBA;IAUE,+BA6BC;IA/BD,sBAAmB;IAGjB,iDAAiD;IACjD,kBAAgC;IAEhC,QAAyB;IACzB,mBAA6C;IAC7C,cAAqC;IAErC,qBAAwB;IACxB,0FAA0F;IAC1F,eAAkE;IAElE,iHAAiH;IACjH,uBAAgD;IAChD,mFAAmF;IACnF,iCAA0D;IAC1D,uIAAuI;IACvI,yBAA4B;IAC5B,kIAAkI;IAClI,kBAAqB;IACrB,uIAAuI;IACvI,0BAAwE;IAU1E,mBAEC;IAED;;;;;;;;;MAWC;IAED,kFAAkF;IAClF,oBAGC;IAED,qDAAqD;IACrD,8CAyCC;IAED;;;;;OAKG;IACH,aAHW,GAAC,cACD,GAAC,QAiCX;IAED,yHAAyH;IACzH,yCAgCC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BAhO8B,mBAAmB"}