@newrelic/browser-agent 1.252.0 → 1.253.0

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

@@ -19,6 +19,7 @@ var _runtime = require("../../../common/constants/runtime");
 var _constants = require("../constants");
 var _features = require("../../../loaders/features/features");
 var _aggregateBase = require("../../utils/aggregate-base");
+var _nreum = require("../../../common/window/nreum");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -37,21 +38,20 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.stackReported = {};
     this.observedAt = {};
     this.pageviewReported = {};
-    this.errorCache = {};
+    this.bufferedErrorsUnderSpa = {};
     this.currentBody = undefined;
     this.errorOnPage = false;
 
     // this will need to change to match whatever ee we use in the instrument
-    this.ee.on('interactionSaved', interaction => this.onInteractionSaved(interaction));
-
-    // this will need to change to match whatever ee we use in the instrument
-    this.ee.on('interactionDiscarded', interaction => this.onInteractionDiscarded(interaction));
+    this.ee.on('interactionDone', (interaction, wasSaved) => this.onInteractionDone(interaction, wasSaved));
     (0, _registerHandler.registerHandler)('err', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
     (0, _registerHandler.registerHandler)('ierr', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('softNavFlush', (interactionId, wasFinished, softNavAttrs) => this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs), this.featureName, this.ee); // when an ixn is done or cancelled
+
     const harvestTimeSeconds = (0, _config.getConfigurationValue)(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10;
     const scheduler = new _harvestScheduler.HarvestScheduler('jserrors', {
       onFinished: function () {
@@ -193,82 +193,93 @@ class Aggregate extends _aggregateBase.AggregateBase {
       time
     };
 
-    // sr, stn and spa aggregators listen to this event - stn sends the error in its payload,
-    // and spa annotates the error with interaction info
-    const msg = [type, bucketHash, params, newMetrics];
-    (0, _handle.handle)('errorAgg', msg, undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
-    (0, _handle.handle)('errorAgg', msg, undefined, _features.FEATURE_NAMES.spa, this.ee);
-    (0, _handle.handle)('errorAgg', msg, undefined, _features.FEATURE_NAMES.sessionReplay, this.ee);
-
+    // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
+    const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes];
+    (0, _handle.handle)('errorAgg', jsErrorEvent, undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
+    (0, _handle.handle)('errorAgg', jsErrorEvent, undefined, _features.FEATURE_NAMES.sessionReplay, this.ee);
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return;
-    var att = (0, _config.getInfo)(this.agentIdentifier).jsAttributes;
-    if (params._interactionId != null) {
-      // hold on to the error until the interaction finishes
-      this.errorCache[params._interactionId] = this.errorCache[params._interactionId] || [];
-      this.errorCache[params._interactionId].push([type, bucketHash, params, newMetrics, att, customAttributes]);
+    const softNavInUse = Boolean((0, _nreum.getNREUMInitializedAgent)(this.agentIdentifier)?.features[_features.FEATURE_NAMES.softNav]);
+    // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
+    // They each will also tack on their respective properties to the params object as part of the decision flow.
+    if (softNavInUse) (0, _handle.handle)('jserror', [params, time], undefined, _features.FEATURE_NAMES.softNav, this.ee);else (0, _handle.handle)('errorAgg', jsErrorEvent, undefined, _features.FEATURE_NAMES.spa, this.ee);
+    if (params.browserInteractionId && !params._softNavFinished) {
+      // hold onto the error until the in-progress interaction is done, eithered saved or discarded
+      this.bufferedErrorsUnderSpa[params.browserInteractionId] ??= [];
+      this.bufferedErrorsUnderSpa[params.browserInteractionId].push(jsErrorEvent);
+    } else if (params._interactionId != null) {
+      // same as above, except tailored for the way old spa does it
+      this.bufferedErrorsUnderSpa[params._interactionId] = this.bufferedErrorsUnderSpa[params._interactionId] || [];
+      this.bufferedErrorsUnderSpa[params._interactionId].push(jsErrorEvent);
     } else {
-      // store custom attributes
-      var customParams = {};
-      (0, _mapOwn.mapOwn)(att, setCustom);
-      if (customAttributes) {
-        (0, _mapOwn.mapOwn)(customAttributes, setCustom);
-      }
-      var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(customParams));
-      var aggregateHash = bucketHash + ':' + jsAttributesHash;
-      this.aggregator.store(type, aggregateHash, params, newMetrics, customParams);
+      // Either there is no interaction (then all these params properties will be undefined) OR there's a related soft navigation that's already completed.
+      // The old spa does not look up completed interactions at all, so there's no need to consider it.
+      this.#storeJserrorForHarvest(jsErrorEvent, params.browserInteractionId !== undefined, params._softNavAttributes);
     }
+  }
+  #storeJserrorForHarvest(errorInfoArr, softNavOccurredFinished) {
+    let softNavCustomAttrs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    let [type, bucketHash, params, newMetrics, localAttrs] = errorInfoArr;
+    const allCustomAttrs = {};
+    if (softNavOccurredFinished) {
+      Object.entries(softNavCustomAttrs).forEach(_ref => {
+        let [k, v] = _ref;
+        return setCustom(k, v);
+      }); // when an ixn finishes, it'll include stuff in jsAttributes + attrs specific to the ixn
+      bucketHash += params.browserInteractionId;
+      delete params._softNavAttributes; // cleanup temp properties from synchronous evaluation; this is harmless when async from soft nav (properties DNE)
+      delete params._softNavFinished;
+    } else {
+      // interaction was cancelled -> error should not be associated OR there was no interaction
+      Object.entries((0, _config.getInfo)(this.agentIdentifier).jsAttributes).forEach(_ref2 => {
+        let [k, v] = _ref2;
+        return setCustom(k, v);
+      });
+      delete params.browserInteractionId;
+    }
+    if (localAttrs) Object.entries(localAttrs).forEach(_ref3 => {
+      let [k, v] = _ref3;
+      return setCustom(k, v);
+    }); // local custom attrs are applied in either case with the highest precedence
+
+    const jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(allCustomAttrs));
+    const aggregateHash = bucketHash + ':' + jsAttributesHash;
+    this.aggregator.store(type, aggregateHash, params, newMetrics, allCustomAttrs);
     function setCustom(key, val) {
-      customParams[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
+      allCustomAttrs[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
     }
   }
-  onInteractionSaved(interaction) {
-    if (!this.errorCache[interaction.id] || this.blocked) return;
-    this.errorCache[interaction.id].forEach(item => {
-      var customParams = {};
-      var globalCustomParams = item[4];
-      var localCustomParams = item[5];
-      (0, _mapOwn.mapOwn)(globalCustomParams, setCustom);
-      (0, _mapOwn.mapOwn)(interaction.root.attrs.custom, setCustom);
-      (0, _mapOwn.mapOwn)(localCustomParams, setCustom);
+
+  // TO-DO: Remove this function when old spa is taken out. #storeJserrorForHarvest handles the work with the softnav feature.
+  onInteractionDone(interaction, wasSaved) {
+    if (!this.bufferedErrorsUnderSpa[interaction.id] || this.blocked) return;
+    this.bufferedErrorsUnderSpa[interaction.id].forEach(item => {
+      var allCustomAttrs = {};
+      const localCustomAttrs = item[4];
+      (0, _mapOwn.mapOwn)(interaction.root.attrs.custom, setCustom); // tack on custom attrs from the interaction
+      (0, _mapOwn.mapOwn)(localCustomAttrs, setCustom);
       var params = item[2];
-      params.browserInteractionId = interaction.root.attrs.id;
-      delete params._interactionId;
-      if (params._interactionNodeId) {
-        params.parentNodeId = params._interactionNodeId.toString();
-        delete params._interactionNodeId;
-      }
-      var hash = item[1] + interaction.root.attrs.id;
-      var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(customParams));
-      var aggregateHash = hash + ':' + jsAttributesHash;
-      this.aggregator.store(item[0], aggregateHash, params, item[3], customParams);
-      function setCustom(key, val) {
-        customParams[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
+      if (wasSaved) {
+        params.browserInteractionId = interaction.root.attrs.id;
+        if (params._interactionNodeId) params.parentNodeId = params._interactionNodeId.toString();
       }
-    });
-    delete this.errorCache[interaction.id];
-  }
-  onInteractionDiscarded(interaction) {
-    if (!this.errorCache || !this.errorCache[interaction.id] || this.blocked) return;
-    this.errorCache[interaction.id].forEach(item => {
-      var customParams = {};
-      var globalCustomParams = item[4];
-      var localCustomParams = item[5];
-      (0, _mapOwn.mapOwn)(globalCustomParams, setCustom);
-      (0, _mapOwn.mapOwn)(interaction.root.attrs.custom, setCustom);
-      (0, _mapOwn.mapOwn)(localCustomParams, setCustom);
-      var params = item[2];
       delete params._interactionId;
       delete params._interactionNodeId;
-      var hash = item[1];
-      var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(customParams));
+      var hash = wasSaved ? item[1] + interaction.root.attrs.id : item[1];
+      var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(allCustomAttrs));
       var aggregateHash = hash + ':' + jsAttributesHash;
-      this.aggregator.store(item[0], aggregateHash, item[2], item[3], customParams);
+      this.aggregator.store(item[0], aggregateHash, params, item[3], allCustomAttrs);
       function setCustom(key, val) {
-        customParams[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
+        allCustomAttrs[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
       }
     });
-    delete this.errorCache[interaction.id];
+    delete this.bufferedErrorsUnderSpa[interaction.id];
+  }
+  onSoftNavNotification(interactionId, wasFinished, softNavAttrs) {
+    if (this.blocked) return;
+    this.bufferedErrorsUnderSpa[interactionId]?.forEach(jsErrorEvent => this.#storeJserrorForHarvest(jsErrorEvent, wasFinished, softNavAttrs) // this should not modify the re-used softNavAttrs contents
+    );
+    delete this.bufferedErrorsUnderSpa[interactionId]; // wipe the list of jserrors so they aren't duplicated by another call to the same id
   }
 }
 exports.Aggregate = Aggregate;

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

@@ -137,7 +137,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
           this.drain();
         } catch (err) {
           this.ee.abort();
-          (0, _console.warn)('RUM call failed. Agent shutting down.');
+          (0, _console.warn)('RUM call failed. Agent shutting down.', err);
         }
       }
     });

package/dist/cjs/features/page_view_event/aggregate/initialized-features.js

@@ -30,6 +30,7 @@ function getActivatedFeaturesFlags(agentId) {
         case _features.FEATURE_NAMES.sessionTrace:
           flagArr.push('stn');
           break;
+        case _features.FEATURE_NAMES.softNav:
         case _features.FEATURE_NAMES.spa:
           flagArr.push('spa');
           break;

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

@@ -58,103 +58,100 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.recorder = args?.recorder;
     if (this.recorder) this.recorder.parent = this;
     (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-    const shouldSetup = (0, _config.getConfigurationValue)(agentIdentifier, 'privacy.cookies_enabled') === true && (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.enabled') === true;
-    if (shouldSetup) {
-      // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
-      this.ee.on(_constants3.SESSION_EVENTS.RESET, () => {
-        this.scheduler.runHarvest();
-        this.abort(_constants.ABORT_REASONS.RESET);
-      });
-
-      // The SessionEntity class can emit a message indicating the session was paused (visibility change). This feature must stop recording if that occurs.
-      this.ee.on(_constants3.SESSION_EVENTS.PAUSE, () => {
-        this.recorder?.stopRecording();
-      });
-      // The SessionEntity class can emit a message indicating the session was resumed (visibility change). This feature must start running again (if already running) if that occurs.
-      this.ee.on(_constants3.SESSION_EVENTS.RESUME, () => {
-        if (!this.recorder) return;
-        // if the mode changed on a different tab, it needs to update this instance to match
-        const {
-          session
-        } = (0, _config.getRuntime)(this.agentIdentifier);
-        this.mode = session.state.sessionReplayMode;
-        if (!this.initialized || this.mode === _constants3.MODE.OFF) return;
-        this.recorder?.startRecording();
-      });
-      this.ee.on(_constants3.SESSION_EVENTS.UPDATE, (type, data) => {
-        if (!this.recorder || !this.initialized || this.blocked || type !== _constants3.SESSION_EVENT_TYPES.CROSS_TAB) return;
-        if (this.mode !== _constants3.MODE.OFF && data.sessionReplayMode === _constants3.MODE.OFF) this.abort(_constants.ABORT_REASONS.CROSS_TAB);
-        this.mode = data.sessionReplay;
-      });
 
-      // Bespoke logic for blobs endpoint.
-      this.scheduler = new _harvestScheduler.HarvestScheduler('browser/blobs', {
-        onFinished: this.onHarvestFinished.bind(this),
-        retryDelay: this.harvestTimeSeconds,
-        getPayload: this.prepareHarvest.bind(this),
-        raw: true
-      }, this);
-      if (this.recorder?.getEvents().type === 'preloaded') {
-        this.prepUtils().then(() => {
-          this.scheduler.runHarvest();
-        });
-      }
-      (0, _registerHandler.registerHandler)('recordReplay', () => {
-        // 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)('pauseReplay', () => {
-        this.forceStop(this.mode !== _constants3.MODE.ERROR);
-      }, this.featureName, this.ee);
+    // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
+    this.ee.on(_constants3.SESSION_EVENTS.RESET, () => {
+      this.scheduler.runHarvest();
+      this.abort(_constants.ABORT_REASONS.RESET);
+    });
 
-      // Wait for an error to be reported.  This currently is wrapped around the "Error" feature.  This is a feature-feature dependency.
-      // This was to ensure that all errors, including those on the page before load and those handled with "noticeError" are accounted for. Needs evalulation
-      (0, _registerHandler.registerHandler)('errorAgg', e => {
-        this.errorNoticed = true;
-        if (this.recorder) this.recorder.currentBufferTarget.hasError = true;
-        // run once
-        if (this.mode === _constants3.MODE.ERROR && _runtime.globalScope?.document.visibilityState === 'visible') {
-          this.switchToFull();
-        }
-      }, this.featureName, this.ee);
+    // The SessionEntity class can emit a message indicating the session was paused (visibility change). This feature must stop recording if that occurs.
+    this.ee.on(_constants3.SESSION_EVENTS.PAUSE, () => {
+      this.recorder?.stopRecording();
+    });
+    // The SessionEntity class can emit a message indicating the session was resumed (visibility change). This feature must start running again (if already running) if that occurs.
+    this.ee.on(_constants3.SESSION_EVENTS.RESUME, () => {
+      if (!this.recorder) return;
+      // if the mode changed on a different tab, it needs to update this instance to match
       const {
-        error_sampling_rate,
-        sampling_rate,
-        autoStart,
-        block_selector,
-        mask_text_selector,
-        mask_all_inputs,
-        inline_stylesheet,
-        inline_images,
-        collect_fonts
-      } = (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay');
-      this.waitForFlags(['sr']).then(_ref => {
-        let [flagOn] = _ref;
-        this.entitled = flagOn;
-        if (!this.entitled && this.recorder?.recording) {
-          this.recorder.abort(_constants.ABORT_REASONS.ENTITLEMENTS);
-          (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/EnabledNotEntitled/Detected'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-        }
-        this.initializeRecording(Math.random() * 100 < error_sampling_rate, Math.random() * 100 < sampling_rate);
-      }).then(() => _sharedChannel.sharedChannel.onReplayReady(this.mode)); // notify watchers that replay started with the mode
+        session
+      } = (0, _config.getRuntime)(this.agentIdentifier);
+      this.mode = session.state.sessionReplayMode;
+      if (!this.initialized || this.mode === _constants3.MODE.OFF) return;
+      this.recorder?.startRecording();
+    });
+    this.ee.on(_constants3.SESSION_EVENTS.UPDATE, (type, data) => {
+      if (!this.recorder || !this.initialized || this.blocked || type !== _constants3.SESSION_EVENT_TYPES.CROSS_TAB) return;
+      if (this.mode !== _constants3.MODE.OFF && data.sessionReplayMode === _constants3.MODE.OFF) this.abort(_constants.ABORT_REASONS.CROSS_TAB);
+      this.mode = data.sessionReplay;
+    });
 
-      /** 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);
-      if (collect_fonts === true) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/CollectFonts/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-      if (inline_stylesheet !== true) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/InlineStylesheet/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-      if (inline_images === true) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/InlineImages/Modifed'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-      if (mask_all_inputs !== true) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/MaskAllInputs/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-      if (block_selector !== '[data-nr-block]') (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/BlockSelector/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-      if (mask_text_selector !== '*') (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/MaskTextSelector/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-      (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/SamplingRate/Value', sampling_rate], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-      (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/ErrorSamplingRate/Value', error_sampling_rate], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-      this.drain();
-    }
+    // Bespoke logic for blobs endpoint.
+    this.scheduler = new _harvestScheduler.HarvestScheduler('browser/blobs', {
+      onFinished: this.onHarvestFinished.bind(this),
+      retryDelay: this.harvestTimeSeconds,
+      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);
+
+    // Wait for an error to be reported.  This currently is wrapped around the "Error" feature.  This is a feature-feature dependency.
+    // This was to ensure that all errors, including those on the page before load and those handled with "noticeError" are accounted for. Needs evalulation
+    (0, _registerHandler.registerHandler)('errorAgg', e => {
+      this.errorNoticed = true;
+      if (this.recorder) this.recorder.currentBufferTarget.hasError = true;
+      // run once
+      if (this.mode === _constants3.MODE.ERROR && _runtime.globalScope?.document.visibilityState === 'visible') {
+        this.switchToFull();
+      }
+    }, this.featureName, this.ee);
+    const {
+      error_sampling_rate,
+      sampling_rate,
+      autoStart,
+      block_selector,
+      mask_text_selector,
+      mask_all_inputs,
+      inline_stylesheet,
+      inline_images,
+      collect_fonts
+    } = (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay');
+    this.waitForFlags(['sr']).then(_ref => {
+      let [flagOn] = _ref;
+      this.entitled = flagOn;
+      if (!this.entitled && this.recorder?.recording) {
+        this.abort(_constants.ABORT_REASONS.ENTITLEMENTS);
+        (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/EnabledNotEntitled/Detected'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+        return;
+      }
+      this.initializeRecording(Math.random() * 100 < error_sampling_rate, Math.random() * 100 < sampling_rate);
+    }).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
+    });
+
+    /** 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);
+    if (collect_fonts === true) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/CollectFonts/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    if (inline_stylesheet !== true) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/InlineStylesheet/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    if (inline_images === true) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/InlineImages/Modifed'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    if (mask_all_inputs !== true) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/MaskAllInputs/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    if (block_selector !== '[data-nr-block]') (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/BlockSelector/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    if (mask_text_selector !== '*') (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/MaskTextSelector/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/SamplingRate/Value', sampling_rate], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/ErrorSamplingRate/Value', error_sampling_rate], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    this.drain();
   }
   switchToFull() {
     this.mode = _constants3.MODE.FULL;
@@ -202,6 +199,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
         return;
       }
     }
+    if (this.recorder?.getEvents().type === 'preloaded') {
+      this.prepUtils().then(() => {
+        this.scheduler.runHarvest();
+      });
+    }
     if (!this.recorder) {
       try {
         // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
@@ -394,7 +396,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     });
     this.recorder?.clearTimestamps?.();
     this.ee.emit('REPLAY_ABORTED');
-    this.recorder?.clearBuffer?.();
+    while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.();
   }
   syncWithSessionManager() {
     let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

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

@@ -3,10 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-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.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;
+const SR_EVENT_EMITTER_TYPES = exports.SR_EVENT_EMITTER_TYPES = {
+  RECORD: 'recordReplay',
+  PAUSE: 'pauseReplay'
+};
 const AVG_COMPRESSION = exports.AVG_COMPRESSION = 0.12;
 const RRWEB_EVENT_TYPES = exports.RRWEB_EVENT_TYPES = {
   DomContentLoaded: 0,

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

@@ -7,6 +7,7 @@ exports.Instrument = void 0;
 var _constants = require("../../../common/session/constants");
 var _instrumentBase = require("../../utils/instrument-base");
 var _constants2 = require("../constants");
+var _utils = require("../shared/utils");
 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.
@@ -23,15 +24,29 @@ class Instrument extends _instrumentBase.InstrumentBase {
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, _constants2.FEATURE_NAME, auto);
+    let session;
     try {
-      const session = JSON.parse(localStorage.getItem('NRBA_SESSION'));
-      if (session.sessionReplayMode !== _constants.MODE.OFF) {
-        this.#startRecording(session.sessionReplayMode);
-      } else {
-        this.importAggregator({});
-      }
-    } catch (err) {
-      this.importAggregator({});
+      session = JSON.parse(localStorage.getItem("".concat(_constants.PREFIX, "_").concat(_constants.DEFAULT_KEY)));
+    } catch (err) {}
+    if (this.#canPreloadRecorder(session)) {
+      this.#startRecording(session?.sessionReplayMode);
+    } else {
+      this.importAggregator();
+    }
+  }
+
+  // At this point wherein session state exists already but we haven't init SessionEntity aka verify timers.
+  #canPreloadRecorder(session) {
+    if (!session) {
+      // 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.agentIdentifier);
+    } 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.agentIdentifier);
     }
   }
   async #startRecording(mode) {
@@ -43,6 +58,7 @@ class Instrument extends _instrumentBase.InstrumentBase {
       agentIdentifier: this.agentIdentifier
     });
     this.recorder.startRecording();
+    this.abortHandler = this.recorder.stopRecording;
     this.importAggregator({
       recorder: this.recorder
     });

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

@@ -115,14 +115,15 @@ class Recorder {
     const incompletes = _stylesheetEvaluator.stylesheetEvaluator.evaluate();
     /** Only stop ignoring data if already ignoring and a new valid snapshap is taking place (0 incompletes and we get a meta node for the snap) */
     if (!incompletes && this.#fixing && event.type === _constants.RRWEB_EVENT_TYPES.Meta) this.#fixing = false;
-    if (incompletes) {
+    if (incompletes > 0) {
       /** wait for the evaluator to download/replace the incompletes' src code and then take a new snap */
       _stylesheetEvaluator.stylesheetEvaluator.fix().then(failedToFix => {
-        if (failedToFix) {
+        if (failedToFix > 0) {
           this.currentBufferTarget.inlinedAllStylesheets = false;
           this.shouldFix = false;
-          (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/Payload/Missing-Inline-Css/Failed', failedToFix], undefined, _features.FEATURE_NAMES.metrics, this.parent.ee);
-        } else (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/Payload/Missing-Inline-Css/Fixed', incompletes - failedToFix], undefined, _features.FEATURE_NAMES.metrics, this.parent.ee);
+        }
+        (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/Payload/Missing-Inline-Css/Failed', failedToFix], undefined, _features.FEATURE_NAMES.metrics, this.parent.ee);
+        (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/Payload/Missing-Inline-Css/Fixed', incompletes - failedToFix], undefined, _features.FEATURE_NAMES.metrics, this.parent.ee);
         this.takeFullSnapshot();
       });
       /** Only start ignoring data if got a faulty snapshot */

package/dist/cjs/features/session_replay/shared/stylesheet-evaluator.js

@@ -24,15 +24,15 @@ class StylesheetEvaluator {
     let incompletes = 0;
     if (_runtime.isBrowserScope) {
       for (let i = 0; i < Object.keys(document.styleSheets).length; i++) {
-        const ss = document.styleSheets[i];
-        if (!this.#evaluated.has(ss)) {
-          this.#evaluated.add(ss);
+        if (!this.#evaluated.has(document.styleSheets[i])) {
+          this.#evaluated.add(document.styleSheets[i]);
           try {
             // eslint-disable-next-line
-            const temp = ss.cssRules;
+            const temp = document.styleSheets[i].cssRules;
           } catch (err) {
+            if (!document.styleSheets[i].href) return;
             incompletes++;
-            this.#fetchProms.push(this.#fetchAndOverride(document.styleSheets[i], ss.href));
+            this.#fetchProms.push(this.#fetchAndOverride(document.styleSheets[i]));
           }
         }
       }
@@ -59,9 +59,10 @@ class StylesheetEvaluator {
   * @param {*} href - The asset href to fetch
   * @returns {Promise}
   */
-  async #fetchAndOverride(target, href) {
+  async #fetchAndOverride(target) {
+    if (!target?.href) return;
     try {
-      const stylesheetContents = await _config.originals.FETCH.bind(window)(href);
+      const stylesheetContents = await _config.originals.FETCH.bind(window)(target.href);
       if (!stylesheetContents.ok) {
         this.failedToFix++;
         return;

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canImportReplayAgg = canImportReplayAgg;
+exports.enableSessionTracking = void 0;
+exports.isPreloadAllowed = isPreloadAllowed;
+var _config = require("../../../common/config/config");
+var _runtime = require("../../../common/constants/runtime");
+const enableSessionTracking = agentId => _runtime.isBrowserScope && (0, _config.getConfigurationValue)(agentId, 'privacy.cookies_enabled') === true;
+exports.enableSessionTracking = enableSessionTracking;
+function hasReplayPrerequisite(agentId) {
+  return _config.originals.MO &&
+  // Session Replay cannot work without Mutation Observer
+  enableSessionTracking &&
+  // 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
+}
+function isPreloadAllowed(agentId) {
+  return (0, _config.getConfigurationValue)(agentId, 'session_replay.preload') === true && hasReplayPrerequisite(agentId);
+}
+function canImportReplayAgg(agentId, sessionMgr) {
+  if (!hasReplayPrerequisite(agentId)) return false;
+  return !!sessionMgr?.isNew || !!sessionMgr?.state.sessionReplayMode; // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
+}