@newrelic/browser-agent 1.258.2 → 1.260.0

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.260.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.259.0...v1.260.0) (2024-05-13)
+
+
+### Features
+
+* Improve time stamping of page view events ([#1026](https://github.com/newrelic/newrelic-browser-agent/issues/1026)) ([67a658d](https://github.com/newrelic/newrelic-browser-agent/commit/67a658d2645b680a479175dff06a4fd95bd6086a))
+
+
+### Bug Fixes
+
+* Add internal error handler to session replay recorder ([#1029](https://github.com/newrelic/newrelic-browser-agent/issues/1029)) ([84c101c](https://github.com/newrelic/newrelic-browser-agent/commit/84c101ccbff8da207bdf215714f49b7d49941388))
+* Adjust session entity to not race between tabs ([#1032](https://github.com/newrelic/newrelic-browser-agent/issues/1032)) ([d86becf](https://github.com/newrelic/newrelic-browser-agent/commit/d86becf2fc02aa133430332aa4e4c2bc26297750))
+
+## [1.259.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.258.2...v1.259.0) (2024-05-08)
+
+
+### Features
+
+* Migrate Session Traces to Use Blob Consumer with Feature Flags ([#821](https://github.com/newrelic/newrelic-browser-agent/issues/821)) ([55b0e00](https://github.com/newrelic/newrelic-browser-agent/commit/55b0e00e9d8dce6d0cdbed978a98302d40123f3d))
+
 ## [1.258.2](https://github.com/newrelic/newrelic-browser-agent/compare/v1.258.1...v1.258.2) (2024-05-07)
 
 

package/dist/cjs/cdn/polyfills.js

@@ -7,6 +7,7 @@ require("core-js/stable/array/flat");
 require("core-js/stable/array/flat-map");
 require("core-js/stable/array/from");
 require("core-js/stable/array/some");
+require("core-js/stable/array/find-index");
 require("core-js/stable/object/assign");
 require("core-js/stable/object/entries");
 require("core-js/stable/object/values");
@@ -19,4 +20,5 @@ require("core-js/stable/object/get-own-property-descriptors");
 require("core-js/stable/url");
 require("core-js/stable/url-search-params");
 require("core-js/stable/string/starts-with");
-require("core-js/stable/number/is-nan");
+require("core-js/stable/number/is-nan");
+require("core-js/stable/string/includes");

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.258.2";
+const VERSION = exports.VERSION = "1.260.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.258.2";
+const VERSION = exports.VERSION = "1.260.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/drain/drain.js

@@ -83,7 +83,7 @@ function drain() {
 function checkCanDrainAll(agentIdentifier) {
   // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
   // that the last feature to call drain triggers drain for all features.
-  const items = [...registry[agentIdentifier]];
+  const items = Array.from(registry[agentIdentifier]);
   if (items.every(_ref => {
     let [key, values] = _ref;
     return values.staged;

package/dist/cjs/common/harvest/harvest-scheduler.js

@@ -38,7 +38,7 @@ class HarvestScheduler extends _sharedContext.SharedContext {
     this.started = false;
     this.timeoutHandle = null;
     this.aborted = false; // this controls the per-interval and final harvests for the scheduler (currently per feature specific!)
-
+    this.harvesting = false;
     this.harvest = new _harvest.Harvest(this.sharedContext);
 
     // unload if EOL mechanism fires
@@ -89,12 +89,14 @@ class HarvestScheduler extends _sharedContext.SharedContext {
   }
   runHarvest(opts) {
     if (this.aborted) return;
+    this.harvesting = true;
 
     /**
      * This is executed immediately after harvest sends the data via XHR, or if there's nothing to send. Note that this excludes on unloading / sendBeacon.
      * @param {Object} result
      */
     const cbRanAfterSend = result => {
+      this.harvesting = false;
       if (opts?.forceNoRetry) result.retry = false; // discard unsent data rather than re-queuing for next harvest attempt
       this.onHarvestFinished(opts, result);
     };
@@ -110,7 +112,7 @@ class HarvestScheduler extends _sharedContext.SharedContext {
       const retry = !opts?.unload && submitMethod === submitData.xhr;
       payload = this.opts.getPayload({
         retry,
-        opts
+        ...opts
       });
       if (!payload) {
         if (this.started) {

package/dist/cjs/common/session/session-entity.js

@@ -74,8 +74,15 @@ class SessionEntity {
       expiresMs = _constants.DEFAULT_EXPIRES_MS,
       inactiveMs = _constants.DEFAULT_INACTIVE_MS
     } = _ref;
+    /** Ensure that certain properties are preserved across a reset if already set */
+    const persistentAttributes = {
+      serverTimeDiff: this.state.serverTimeDiff || model.serverTimeDiff
+    };
     this.state = {};
-    this.sync(model);
+    this.sync({
+      ...model,
+      ...persistentAttributes
+    });
 
     // value is intended to act as the primary value of the k=v pair
     this.state.value = value;

package/dist/cjs/common/timing/time-keeper.js

@@ -5,9 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.TimeKeeper = void 0;
 var _runtime = require("../constants/runtime");
-var _contextualEe = require("../event-emitter/contextual-ee");
 var _config = require("../config/config");
-var _constants = require("../session/constants");
 /**
  * Class used to adjust the timestamp of harvested data to New Relic server time. This
  * is done by tracking the performance timings of the RUM call and applying a calculation
@@ -41,18 +39,7 @@ class TimeKeeper {
   #ready = false;
   constructor(agentIdentifier) {
     this.#session = (0, _config.getRuntime)(agentIdentifier)?.session;
-    if (this.#session) {
-      const ee = _contextualEe.ee.get(agentIdentifier);
-      ee.on(_constants.SESSION_EVENTS.UPDATE, this.#processSessionUpdate.bind(this));
-      ee.on(_constants.SESSION_EVENTS.STARTED, () => {
-        if (this.#ready) {
-          this.#session.write({
-            serverTimeDiff: this.#localTimeDiff
-          });
-        }
-      });
-      this.#processSessionUpdate(null, this.#session.read());
-    }
+    this.processStoredDiff();
   }
   get ready() {
     return this.#ready;
@@ -68,8 +55,8 @@ class TimeKeeper {
    * @param endTime {number} The end time of the RUM request
    */
   processRumRequest(rumRequest, startTime, endTime) {
+    this.processStoredDiff();
     if (this.#ready) return; // Server time calculated from session entity
-
     const responseDateHeader = rumRequest.getResponseHeader('Date');
     if (!responseDateHeader) {
       throw new Error('Missing date header on rum response.');
@@ -80,10 +67,10 @@ class TimeKeeper {
     // Corrected page origin time
     this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset);
     this.#localTimeDiff = _runtime.originTime - this.#correctedOriginTime;
-    if (Number.isNaN(this.#correctedOriginTime)) {
+    if (isNaN(this.#correctedOriginTime)) {
       throw new Error('Date header invalid format.');
     }
-    if (this.#session) this.#session.write({
+    this.#session?.write({
       serverTimeDiff: this.#localTimeDiff
     });
     this.#ready = true;
@@ -108,19 +95,11 @@ class TimeKeeper {
     return Math.floor(timestamp - this.#localTimeDiff);
   }
 
-  /**
-   * Processes a session entity update payload to extract the server time calculated.
-   * @param {import('../session/constants').SESSION_EVENT_TYPES | null} type
-   * @param {Object} data
-   */
-  #processSessionUpdate(type, data) {
-    if (typeof data?.serverTimeDiff !== 'number') return;
-    if (!type && !this.#ready ||
-    // This captures the initial read from the session entity when the timekeeper first initializes
-    type === _constants.SESSION_EVENT_TYPES.CROSS_TAB // This captures any cross-tab write of the session entity
-    ) {
-      // This captures the initial read from the session entity when the timekeeper first initializes
-      this.#localTimeDiff = data.serverTimeDiff;
+  /** Process the session entity and use the info to set the main time calculations if present */
+  processStoredDiff() {
+    const storedServerTimeDiff = this.#session?.read()?.serverTimeDiff;
+    if (typeof storedServerTimeDiff === 'number' && !isNaN(storedServerTimeDiff)) {
+      this.#localTimeDiff = storedServerTimeDiff;
       this.#correctedOriginTime = _runtime.originTime - this.#localTimeDiff;
       this.#ready = true;
     }

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

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.FEATURE_NAME = void 0;
+exports.MAX_PAYLOAD_SIZE = exports.FEATURE_NAME = void 0;
 var _features = require("../../loaders/features/features");
-const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.ajax;
+const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.ajax;
+const MAX_PAYLOAD_SIZE = exports.MAX_PAYLOAD_SIZE = 1000000;

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

@@ -7,7 +7,6 @@ exports.Instrument = void 0;
 var _handle = require("../../../common/event-emitter/handle");
 var _instrumentBase = require("../../utils/instrument-base");
 var _constants = require("../constants");
-var _features = require("../../../loaders/features/features");
 var _runtime = require("../../../common/constants/runtime");
 var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
 var _now = require("../../../common/timing/now");
@@ -30,7 +29,7 @@ class Instrument extends _instrumentBase.InstrumentBase {
     } catch (e) {}
     this.ee.on('internal-error', error => {
       if (!this.abortHandler) return;
-      (0, _handle.handle)('ierr', [(0, _castError.castError)(error), (0, _now.now)(), true, {}, this.#replayRunning], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+      (0, _handle.handle)('ierr', [(0, _castError.castError)(error), (0, _now.now)(), true, {}, this.#replayRunning], undefined, this.featureName, this.ee);
     });
     this.ee.on(_constants2.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
       this.#replayRunning = isRunning;
@@ -39,11 +38,11 @@ class Instrument extends _instrumentBase.InstrumentBase {
       if (!this.abortHandler) return;
       (0, _handle.handle)('err', [(0, _castError.castPromiseRejectionEvent)(promiseRejectionEvent), (0, _now.now)(), false, {
         unhandledPromiseRejection: 1
-      }, this.#replayRunning], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+      }, this.#replayRunning], undefined, this.featureName, this.ee);
     }, (0, _eventListenerOpts.eventListenerOpts)(false, this.removeOnAbort?.signal));
     _runtime.globalScope.addEventListener('error', errorEvent => {
       if (!this.abortHandler) return;
-      (0, _handle.handle)('err', [(0, _castError.castErrorEvent)(errorEvent), (0, _now.now)(), false, {}, this.#replayRunning], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+      (0, _handle.handle)('err', [(0, _castError.castErrorEvent)(errorEvent), (0, _now.now)(), false, {}, this.#replayRunning], undefined, this.featureName, this.ee);
     }, (0, _eventListenerOpts.eventListenerOpts)(false, this.removeOnAbort?.signal));
     this.abortHandler = this.#abort; // we also use this as a flag to denote that the feature is active or on and handling errors
     this.importAggregator();

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

@@ -124,8 +124,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
       if (this.resourcesSent) return;
       this.resourcesSent = true; // make sure this only gets sent once
 
-      const agentRuntime = (0, _config.getRuntime)(this.agentIdentifier);
-
       // Capture SMs around network resources using the performance API to assess
       // work to split this out from the ST nodes
       // differentiate between internal+external and ajax+non-ajax
@@ -146,12 +144,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
         }
       });
 
-      // Capture SMs for session trace if active (`ptid` is set when returned by replay ingest).
-      // Retain these SMs while we are working through the session_replay feature
-      if (agentRuntime.ptid) {
-        this.storeSupportabilityMetrics('PageSession/Feature/SessionTrace/DurationMs', Math.round(performance.now()));
-      }
-
       // Capture SMs for performance markers and measures to assess the usage and possible inclusion of this
       // data in the agent for use in NR
       if (typeof performance !== 'undefined') {

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

@@ -32,7 +32,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.timeToFirstByte = 0;
     this.firstByteToWindowLoad = 0; // our "frontend" duration
     this.firstByteToDomContent = 0; // our "dom processing" duration
-
+    this.timeKeeper = new _timeKeeper.TimeKeeper(this.agentIdentifier);
     if (_runtime.isBrowserScope) {
       _timeToFirstByte.timeToFirstByte.subscribe(_ref => {
         let {
@@ -118,6 +118,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     queryParameters.fp = _firstPaint.firstPaint.current.value;
     queryParameters.fcp = _firstContentfulPaint.firstContentfulPaint.current.value;
+    if (this.timeKeeper?.ready) {
+      queryParameters.timestamp = this.timeKeeper.convertRelativeTimestamp((0, _now.now)());
+    }
     const rumStartTime = (0, _now.now)();
     harvester.send({
       endpoint: 'rum',
@@ -142,15 +145,14 @@ class Aggregate extends _aggregateBase.AggregateBase {
           return;
         }
         try {
-          const timeKeeper = new _timeKeeper.TimeKeeper(this.agentIdentifier);
-          timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime);
-          if (!timeKeeper.ready) throw new Error('TimeKeeper not ready');
-          agentRuntime.timeKeeper = timeKeeper;
+          this.timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime);
+          if (!this.timeKeeper.ready) throw new Error('TimeKeeper not ready');
+          agentRuntime.timeKeeper = this.timeKeeper;
         } catch (error) {
           (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/Failed'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
           (0, _drain.drain)(this.agentIdentifier, _features.FEATURE_NAMES.metrics, true);
           this.ee.abort();
-          (0, _console.warn)('Could not calculate New Relic server time. Agent shutting down.');
+          (0, _console.warn)('Could not calculate New Relic server time. Agent shutting down.', error);
           return;
         }
         try {

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

@@ -96,15 +96,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
       getPayload: this.prepareHarvest.bind(this),
       raw: true
     }, this);
-    (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.RECORD, () => {
-      // if it has aborted or BCS returned bad entitlements, do not allow
-      if (this.blocked || !this.entitled) return;
-      // if it isnt already (fully) initialized... initialize it
-      if (!this.recorder) this.initializeRecording(false, true, true);
-      // its been initialized and imported the recorder but its not recording (mode === off || error)
-      else if (this.mode !== _constants3.MODE.FULL) this.switchToFull();
-      // if it gets all the way to here, that means a full session is already recording... do nothing
-    }, this.featureName, this.ee);
     (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.PAUSE, () => {
       this.forceStop(this.mode !== _constants3.MODE.ERROR);
     }, this.featureName, this.ee);
@@ -122,9 +113,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
       inline_images,
       collect_fonts
     } = (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay');
-    this.waitForFlags(['sr']).then(_ref => {
-      let [flagOn] = _ref;
-      this.entitled = flagOn;
+    this.waitForFlags(['srs', 'sr']).then(_ref => {
+      let [srMode, entitled] = _ref;
+      this.entitled = !!entitled;
       if (!this.entitled) {
         (0, _drain.deregisterDrain)(this.agentIdentifier, this.featureName);
         if (this.recorder?.recording) {
@@ -134,11 +125,14 @@ class Aggregate extends _aggregateBase.AggregateBase {
         return;
       }
       this.drain();
-      this.initializeRecording(Math.random() * 100 < error_sampling_rate, Math.random() * 100 < sampling_rate);
+      this.initializeRecording(srMode);
     }).then(() => {
-      if (this.mode === _constants3.MODE.OFF) args?.recorder?.stopRecording(); // stop any conservative preload recording launched by instrument
-      _sharedChannel.sharedChannel.onReplayReady(this.mode); // notify watchers that replay started with the mode
-    });
+      if (this.mode === _constants3.MODE.OFF) {
+        this.recorder?.stopRecording(); // stop any conservative preload recording launched by instrument
+        while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.();
+      }
+      _sharedChannel.sharedChannel.onReplayReady(this.mode);
+    }); // notify watchers that replay started with the mode
 
     /** Detect if the default configs have been altered and report a SM.  This is useful to evaluate what the reasonable defaults are across a customer base over time */
     if (!autoStart) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/AutoStart/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
@@ -181,7 +175,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
    * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
    * @returns {void}
    */
-  async initializeRecording(errorSample, fullSample, ignoreSession) {
+  async initializeRecording(srMode, ignoreSession) {
     this.initialized = true;
     if (!this.entitled) return;
 
@@ -196,23 +190,17 @@ class Aggregate extends _aggregateBase.AggregateBase {
       timeKeeper
     } = (0, _config.getRuntime)(this.agentIdentifier);
     this.timeKeeper = timeKeeper;
-    if (!session.isNew && !ignoreSession) {
+    if (this.recorder?.parent.trigger === _constants.TRIGGERS.API && this.recorder?.recording) {
+      this.mode = _constants3.MODE.FULL;
+    } else if (!session.isNew && !ignoreSession) {
       // inherit the mode of the existing session
       this.mode = session.state.sessionReplayMode;
     } else {
       // The session is new... determine the mode the new session should start in
-      if (fullSample) this.mode = _constants3.MODE.FULL; // full mode has precedence over error mode
-      else if (errorSample) this.mode = _constants3.MODE.ERROR;
-      // If neither are selected, then don't record (early return)
-      else {
-        return;
-      }
-    }
-    if (this.recorder?.getEvents().type === 'preloaded') {
-      this.prepUtils().then(() => {
-        this.scheduler.runHarvest();
-      });
+      this.mode = srMode;
     }
+    // If off, then don't record (early return)
+    if (this.mode === _constants3.MODE.OFF) return;
     if (!this.recorder) {
       try {
         // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
@@ -230,13 +218,20 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
     // 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 === _constants3.MODE.ERROR && this.errorNoticed) this.mode = _constants3.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.
-    // If an error happened in ERROR mode before we've gotten to this stage, it will have already set the mode to FULL
-    if (this.mode === _constants3.MODE.FULL && !this.scheduler.started) {
-      // We only report (harvest) in FULL mode
-      this.scheduler.startTimer(this.harvestTimeSeconds);
+    if (this.mode === _constants3.MODE.FULL) {
+      // If theres preloaded events and we are in full mode, just harvest immediately to clear up space and for consistency
+      if (this.recorder?.getEvents().type === 'preloaded') {
+        this.prepUtils().then(() => {
+          this.scheduler.runHarvest();
+        });
+      }
+      // 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.
+      // If an error happened in ERROR mode before we've gotten to this stage, it will have already set the mode to FULL
+      if (!this.scheduler.started) {
+        // We only report (harvest) in FULL mode
+        this.scheduler.startTimer(this.harvestTimeSeconds);
+      }
     }
     await this.prepUtils();
     if (!this.recorder.recording) this.recorder.startRecording();

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.SR_EVENT_EMITTER_TYPES = exports.RRWEB_EVENT_TYPES = exports.QUERY_PARAM_PADDING = exports.MAX_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = exports.FEATURE_NAME = exports.CHECKOUT_MS = exports.AVG_COMPRESSION = exports.ABORT_REASONS = void 0;
+exports.TRIGGERS = exports.SR_EVENT_EMITTER_TYPES = exports.RRWEB_EVENT_TYPES = exports.QUERY_PARAM_PADDING = exports.MAX_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = exports.FEATURE_NAME = exports.CHECKOUT_MS = exports.AVG_COMPRESSION = exports.ABORT_REASONS = void 0;
 var _constants = require("../../common/session/constants");
 var _features = require("../../loaders/features/features");
 const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.sessionReplay;
@@ -59,4 +59,7 @@ const ABORT_REASONS = exports.ABORT_REASONS = {
   }
 };
 /** Reserved room for query param attrs */
-const QUERY_PARAM_PADDING = exports.QUERY_PARAM_PADDING = 5000;
+const QUERY_PARAM_PADDING = exports.QUERY_PARAM_PADDING = 5000;
+const TRIGGERS = exports.TRIGGERS = {
+  API: 'api'
+};

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

@@ -7,8 +7,8 @@ exports.Instrument = void 0;
 var _handle = require("../../../common/event-emitter/handle");
 var _constants = require("../../../common/session/constants");
 var _instrumentBase = require("../../utils/instrument-base");
-var _constants2 = require("../constants");
 var _utils = require("../shared/utils");
+var _constants2 = require("../constants");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 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 && Object.prototype.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 2023 New Relic Corporation. All rights reserved.
@@ -22,6 +22,7 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  */
 class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants2.FEATURE_NAME;
+  #mode;
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, _constants2.FEATURE_NAME, auto);
@@ -30,8 +31,12 @@ class Instrument extends _instrumentBase.InstrumentBase {
     try {
       session = JSON.parse(localStorage.getItem("".concat(_constants.PREFIX, "_").concat(_constants.DEFAULT_KEY)));
     } catch (err) {}
+    if ((0, _utils.hasReplayPrerequisite)(agentIdentifier)) {
+      this.ee.on('recordReplay', () => this.#apiStartOrRestartReplay());
+    }
     if (this.#canPreloadRecorder(session)) {
-      this.#startRecording(session?.sessionReplayMode);
+      this.#mode = session?.sessionReplayMode;
+      this.#preloadStartRecording();
     } else {
       this.importAggregator();
     }
@@ -64,21 +69,56 @@ class Instrument extends _instrumentBase.InstrumentBase {
       return (0, _utils.isPreloadAllowed)(this.agentIdentifier);
     }
   }
-  async #startRecording(mode) {
-    const {
-      Recorder
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "recorder" */'../shared/recorder')));
-    this.recorder = new Recorder({
-      mode,
-      agentIdentifier: this.agentIdentifier,
-      ee: this.ee
-    });
-    this.recorder.startRecording();
-    this.abortHandler = this.recorder.stopRecording;
+  #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.
+   */
+  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({
+        mode: this.#mode,
+        agentIdentifier: this.agentIdentifier,
+        trigger,
+        ee: this.ee
+      });
+      this.recorder.startRecording();
+      this.abortHandler = this.recorder.stopRecording;
+    } catch (e) {}
     this.importAggregator({
       recorder: this.recorder,
       errorNoticed: this.errorNoticed
     });
   }
+
+  /**
+   * Called whenever startReplay API is used. That could occur any time, pre or post load.
+   */
+  #apiStartOrRestartReplay() {
+    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);
+    } 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;
+      }
+    }
+  }
 }
 exports.Instrument = Instrument;

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

@@ -101,7 +101,14 @@ class Recorder {
       inlineStylesheet: inline_stylesheet,
       inlineImages: inline_images,
       collectFonts: collect_fonts,
-      checkoutEveryNms: _constants.CHECKOUT_MS[this.parent.mode]
+      checkoutEveryNms: _constants.CHECKOUT_MS[this.parent.mode],
+      /** Emits errors thrown by rrweb directly before bubbling them up to the window */
+      errorHandler: err => {
+        /** capture rrweb errors as "internal" errors only */
+        this.parent.ee.emit('internal-error', [err]);
+        /** returning true informs rrweb to swallow the error instead of throwing it to the window */
+        return true;
+      }
     });
     this.stopRecording = () => {
       this.recording = false;

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

@@ -5,17 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.buildNRMetaNode = buildNRMetaNode;
 exports.canImportReplayAgg = canImportReplayAgg;
-exports.enableSessionTracking = enableSessionTracking;
+exports.hasReplayPrerequisite = hasReplayPrerequisite;
 exports.isPreloadAllowed = isPreloadAllowed;
 var _config = require("../../../common/config/config");
+var _featureGates = require("../../utils/feature-gates");
 var _runtime = require("../../../common/constants/runtime");
-function enableSessionTracking(agentId) {
-  return _runtime.isBrowserScope && (0, _config.getConfigurationValue)(agentId, 'privacy.cookies_enabled') === true;
-}
 function hasReplayPrerequisite(agentId) {
   return !!_config.originals.MO &&
   // Session Replay cannot work without Mutation Observer
-  enableSessionTracking(agentId) &&
+  (0, _featureGates.canEnableSessionTracking)(agentId) &&
   // requires session tracking to be running (hence "session" replay...)
   (0, _config.getConfigurationValue)(agentId, 'session_trace.enabled') === true; // Session Replay as of now is tightly coupled with Session Trace in the UI
 }