@newrelic/browser-agent 1.252.1 → 1.253.0

package/dist/esm/common/wrap/wrap-fetch.js

@@ -6,8 +6,9 @@
  * @file Wraps `fetch` and related methods for instrumentation.
  * This module is used by: ajax, spa.
  */
-import { ee as baseEE, contextId } from '../event-emitter/contextual-ee';
+import { ee as baseEE } from '../event-emitter/contextual-ee';
 import { globalScope } from '../constants/runtime';
+import { ObservationContextManager } from '../context/observation-context-manager';
 var prefix = 'fetch-';
 var bodyPrefix = prefix + 'body-';
 var bodyMethods = ['arrayBuffer', 'blob', 'json', 'text', 'formData'];
@@ -70,7 +71,7 @@ export function wrapFetch(sharedEE) {
         // we are wrapping args in an array so we can preserve the reference
         ee.emit(prefix + 'before-start', [args], ctx);
         var dtPayload;
-        if (ctx[contextId] && ctx[contextId].dt) dtPayload = ctx[contextId].dt;
+        if (ctx[ObservationContextManager.contextId] && ctx[ObservationContextManager.contextId].dt) dtPayload = ctx[ObservationContextManager.contextId].dt;
         var origPromiseFromFetch = fn.apply(this, args);
         ee.emit(prefix + 'start', [args, dtPayload], origPromiseFromFetch);
 

package/dist/esm/common/wrap/wrap-function.js

@@ -7,8 +7,7 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee';
-import { bundleId } from '../ids/bundle-id';
-export const flag = "nr@original:".concat(bundleId);
+import { ObservationContextManager } from '../context/observation-context-manager';
 
 /**
  * A convenience alias of `hasOwnProperty`.
@@ -40,7 +39,7 @@ export function createWrapperWithEmitter(emitter, always) {
    * As a property on a wrapped function, contains the original function.
    * @type {string}
    */
-  wrapFn.flag = flag;
+  wrapFn.flag = ObservationContextManager.contextOriginalId;
   return wrapFn;
 
   /**
@@ -56,7 +55,7 @@ export function createWrapperWithEmitter(emitter, always) {
     // Unless fn is both wrappable and unwrapped, return it unchanged.
     if (notWrappable(fn)) return fn;
     if (!prefix) prefix = '';
-    nrWrapper[flag] = fn;
+    nrWrapper[ObservationContextManager.contextOriginalId] = fn;
     copy(fn, nrWrapper, emitter);
     return nrWrapper;
 
@@ -210,5 +209,5 @@ function copy(from, to, emitter) {
  * @returns {boolean} Whether the passed function is ineligible to be wrapped.
  */
 function notWrappable(fn) {
-  return !(fn && typeof fn === 'function' && fn.apply && !fn[flag]);
+  return !(fn && typeof fn === 'function' && fn.apply && !fn[ObservationContextManager.contextOriginalId]);
 }

package/dist/esm/common/wrap/wrap-promise.js

@@ -7,9 +7,10 @@
  * This module is used by: spa.
  */
 
-import { createWrapperWithEmitter as wrapFn, flag } from './wrap-function';
+import { createWrapperWithEmitter as wrapFn } from './wrap-function';
 import { ee as baseEE } from '../event-emitter/contextual-ee';
 import { globalScope } from '../constants/runtime';
+import { ObservationContextManager } from '../context/observation-context-manager';
 const wrapped = {};
 
 /**
@@ -118,7 +119,7 @@ export function wrapPromise(sharedEE) {
       promiseEE.emit('propagate', [originalThis, true], origFnCallWithThis, false, false);
       return origFnCallWithThis;
     };
-    prevPromiseObj.prototype.then[flag] = prevPromiseOrigThen;
+    prevPromiseObj.prototype.then[ObservationContextManager.contextOriginalId] = prevPromiseOrigThen;
     promiseEE.on('executor-start', function (args) {
       args[0] = promiseWrapper(args[0], 'resolve-', this, null, false);
       args[1] = promiseWrapper(args[1], 'resolve-', this, null, false);

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

@@ -2,7 +2,7 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { registerHandler as register } from '../../../common/event-emitter/register-handler';
+import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { stringify } from '../../../common/util/stringify';
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
 import { handle } from '../../../common/event-emitter/handle';
@@ -14,13 +14,14 @@ import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { parseGQL } from './gql';
+import { getNREUMInitializedAgent } from '../../../common/window/nreum';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
     const agentInit = getConfiguration(agentIdentifier);
     const allAjaxIsEnabled = agentInit.ajax.enabled !== false;
-    register('xhr', storeXhr, this.featureName, this.ee);
+    registerHandler('xhr', storeXhr, this.featureName, this.ee);
     if (!allAjaxIsEnabled) {
       this.drain();
       return; // feature will only collect timeslice metrics & ajax trace nodes if it's not fully enabled
@@ -43,19 +44,23 @@ export class Aggregate extends AggregateBase {
         spaAjaxEvents
       };
     };
-    ee.on('interactionSaved', interaction => {
-      if (!spaAjaxEvents[interaction.id]) return;
-      // remove from the spaAjaxEvents buffer, and let spa harvest it
-      delete spaAjaxEvents[interaction.id];
-    });
-    ee.on('interactionDiscarded', interaction => {
+
+    // --- v Used by old spa feature
+    ee.on('interactionDone', (interaction, wasSaved) => {
       if (!spaAjaxEvents[interaction.id]) return;
-      spaAjaxEvents[interaction.id].forEach(function (item) {
-        // move it from the spaAjaxEvents buffer to the ajaxEvents buffer for harvesting here
-        ajaxEvents.push(item);
-      });
+      if (!wasSaved) {
+        // if the ixn was saved, then its ajax reqs are part of the payload whereas if it was discarded, it should still be harvested in the ajax feature itself
+        spaAjaxEvents[interaction.id].forEach(function (item) {
+          ajaxEvents.push(item);
+        });
+      }
       delete spaAjaxEvents[interaction.id];
     });
+    // --- ^
+    // --- v Used by new soft nav
+    registerHandler('returnAjax', event => ajaxEvents.push(event), this.featureName, this.ee);
+    // --- ^
+
     const scheduler = new HarvestScheduler('events', {
       onFinished: onEventsHarvestFinished,
       getPayload: prepareHarvest
@@ -76,16 +81,26 @@ export class Aggregate extends AggregateBase {
       } else {
         hash = stringify([params.status, params.host, params.pathname]);
       }
+      const shouldCollect = shouldCollectEvent(params);
+      const ajaxMetricDenyListEnabled = agentInit.feature_flags?.includes('ajax_metrics_deny_list');
 
       // store as metric
-      aggregator.store('xhr', hash, params, metrics);
+      if (shouldCollect || !ajaxMetricDenyListEnabled) {
+        aggregator.store('xhr', hash, params, metrics);
+      }
       if (!allAjaxIsEnabled) return;
-      if (!shouldCollectEvent(params)) {
+      if (!shouldCollect) {
         if (params.hostname === beacon || proxyBeacon && params.hostname === proxyBeacon) {
           // This doesn't make a distinction if the same-domain request is going to a different port or path...
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee);
+          if (ajaxMetricDenyListEnabled) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee);
+          }
         } else {
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee);
+          if (ajaxMetricDenyListEnabled) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee);
+          }
         }
         return;
       }
@@ -115,10 +130,13 @@ export class Aggregate extends AggregateBase {
         query: this?.parsedOrigin?.search
       });
       if (event.gql) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length], undefined, FEATURE_NAMES.metrics, ee);
-
-      // if the ajax happened inside an interaction, hold it until the interaction finishes
-      if (this.spaNode) {
-        var interactionId = this.spaNode.interaction.id;
+      const softNavInUse = Boolean(getNREUMInitializedAgent(agentIdentifier)?.features?.[FEATURE_NAMES.softNav]);
+      if (softNavInUse) {
+        // For newer soft nav (when running), pass the event to it for evaluation -- either part of an interaction or is given back
+        handle('ajax', [event], undefined, FEATURE_NAMES.softNav, ee);
+      } else if (this.spaNode) {
+        // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
+        const interactionId = this.spaNode.interaction.id;
         spaAjaxEvents[interactionId] = spaAjaxEvents[interactionId] || [];
         spaAjaxEvents[interactionId].push(event);
       } else {

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

@@ -18,6 +18,7 @@ import { globalScope } from '../../../common/constants/runtime';
 import { FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { AggregateBase } from '../../utils/aggregate-base';
+import { getNREUMInitializedAgent } from '../../../common/window/nreum';
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
@@ -32,21 +33,20 @@ export class Aggregate extends 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));
     register('err', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
     register('ierr', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
+    register('softNavFlush', (interactionId, wasFinished, softNavAttrs) => this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs), this.featureName, this.ee); // when an ixn is done or cancelled
+
     const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10;
     const scheduler = new HarvestScheduler('jserrors', {
       onFinished: function () {
@@ -188,81 +188,92 @@ export class Aggregate extends 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];
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionTrace, this.ee);
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.spa, this.ee);
-    handle('errorAgg', msg, undefined, 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];
+    handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee);
+    handle('errorAgg', jsErrorEvent, undefined, 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 = 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(getNREUMInitializedAgent(this.agentIdentifier)?.features[FEATURE_NAMES.softNav]);
+    // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
+    // They each will also tack on their respective properties to the params object as part of the decision flow.
+    if (softNavInUse) handle('jserror', [params, time], undefined, FEATURE_NAMES.softNav, this.ee);else handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.spa, this.ee);
+    if (params.browserInteractionId && !params._softNavFinished) {
+      // hold onto the error until the in-progress interaction is done, eithered saved or discarded
+      this.bufferedErrorsUnderSpa[params.browserInteractionId] ??= [];
+      this.bufferedErrorsUnderSpa[params.browserInteractionId].push(jsErrorEvent);
+    } else if (params._interactionId != null) {
+      // same as above, except tailored for the way old spa does it
+      this.bufferedErrorsUnderSpa[params._interactionId] = this.bufferedErrorsUnderSpa[params._interactionId] || [];
+      this.bufferedErrorsUnderSpa[params._interactionId].push(jsErrorEvent);
     } else {
-      // store custom attributes
-      var customParams = {};
-      mapOwn(att, setCustom);
-      if (customAttributes) {
-        mapOwn(customAttributes, setCustom);
-      }
-      var jsAttributesHash = stringHashCode(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(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 = stringHashCode(stringify(allCustomAttrs));
+    const aggregateHash = bucketHash + ':' + jsAttributesHash;
+    this.aggregator.store(type, aggregateHash, params, newMetrics, allCustomAttrs);
     function setCustom(key, val) {
-      customParams[key] = val && typeof val === 'object' ? stringify(val) : val;
+      allCustomAttrs[key] = val && typeof val === 'object' ? 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];
-      mapOwn(globalCustomParams, setCustom);
-      mapOwn(interaction.root.attrs.custom, setCustom);
-      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];
+      mapOwn(interaction.root.attrs.custom, setCustom); // tack on custom attrs from the interaction
+      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 = stringHashCode(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' ? 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];
-      mapOwn(globalCustomParams, setCustom);
-      mapOwn(interaction.root.attrs.custom, setCustom);
-      mapOwn(localCustomParams, setCustom);
-      var params = item[2];
       delete params._interactionId;
       delete params._interactionNodeId;
-      var hash = item[1];
-      var jsAttributesHash = stringHashCode(stringify(customParams));
+      var hash = wasSaved ? item[1] + interaction.root.attrs.id : item[1];
+      var jsAttributesHash = stringHashCode(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' ? stringify(val) : val;
+        allCustomAttrs[key] = val && typeof val === 'object' ? 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
   }
 }

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

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

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

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

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

@@ -12,7 +12,7 @@
 
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
-import { ABORT_REASONS, FEATURE_NAME, MAX_PAYLOAD_SIZE, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES } from '../constants';
+import { ABORT_REASONS, FEATURE_NAME, MAX_PAYLOAD_SIZE, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES } from '../constants';
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { sharedChannel } from '../../../common/constants/shared-channel';
@@ -53,103 +53,100 @@ export class Aggregate extends AggregateBase {
     this.recorder = args?.recorder;
     if (this.recorder) this.recorder.parent = this;
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, this.ee);
-    const shouldSetup = getConfigurationValue(agentIdentifier, 'privacy.cookies_enabled') === true && 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(SESSION_EVENTS.RESET, () => {
-        this.scheduler.runHarvest();
-        this.abort(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(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(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
-        } = getRuntime(this.agentIdentifier);
-        this.mode = session.state.sessionReplayMode;
-        if (!this.initialized || this.mode === MODE.OFF) return;
-        this.recorder?.startRecording();
-      });
-      this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
-        if (!this.recorder || !this.initialized || this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return;
-        if (this.mode !== MODE.OFF && data.sessionReplayMode === MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB);
-        this.mode = data.sessionReplay;
-      });
 
-      // Bespoke logic for blobs endpoint.
-      this.scheduler = new 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();
-        });
-      }
-      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 !== 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);
-      registerHandler('pauseReplay', () => {
-        this.forceStop(this.mode !== 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(SESSION_EVENTS.RESET, () => {
+      this.scheduler.runHarvest();
+      this.abort(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
-      registerHandler('errorAgg', e => {
-        this.errorNoticed = true;
-        if (this.recorder) this.recorder.currentBufferTarget.hasError = true;
-        // run once
-        if (this.mode === MODE.ERROR && 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(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(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
-      } = 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(ABORT_REASONS.ENTITLEMENTS);
-          handle(SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/EnabledNotEntitled/Detected'], undefined, FEATURE_NAMES.metrics, this.ee);
-        }
-        this.initializeRecording(Math.random() * 100 < error_sampling_rate, Math.random() * 100 < sampling_rate);
-      }).then(() => sharedChannel.onReplayReady(this.mode)); // notify watchers that replay started with the mode
+        session
+      } = getRuntime(this.agentIdentifier);
+      this.mode = session.state.sessionReplayMode;
+      if (!this.initialized || this.mode === MODE.OFF) return;
+      this.recorder?.startRecording();
+    });
+    this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
+      if (!this.recorder || !this.initialized || this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return;
+      if (this.mode !== MODE.OFF && data.sessionReplayMode === MODE.OFF) this.abort(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) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/AutoStart/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
-      if (collect_fonts === true) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/CollectFonts/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
-      if (inline_stylesheet !== true) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/InlineStylesheet/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
-      if (inline_images === true) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/InlineImages/Modifed'], undefined, FEATURE_NAMES.metrics, this.ee);
-      if (mask_all_inputs !== true) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/MaskAllInputs/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
-      if (block_selector !== '[data-nr-block]') handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/BlockSelector/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
-      if (mask_text_selector !== '*') handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/MaskTextSelector/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
-      handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/SamplingRate/Value', sampling_rate], undefined, FEATURE_NAMES.metrics, this.ee);
-      handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/ErrorSamplingRate/Value', error_sampling_rate], undefined, FEATURE_NAMES.metrics, this.ee);
-      this.drain();
-    }
+    // Bespoke logic for blobs endpoint.
+    this.scheduler = new HarvestScheduler('browser/blobs', {
+      onFinished: this.onHarvestFinished.bind(this),
+      retryDelay: this.harvestTimeSeconds,
+      getPayload: this.prepareHarvest.bind(this),
+      raw: true
+    }, this);
+    registerHandler(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 !== 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);
+    registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
+      this.forceStop(this.mode !== 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
+    registerHandler('errorAgg', e => {
+      this.errorNoticed = true;
+      if (this.recorder) this.recorder.currentBufferTarget.hasError = true;
+      // run once
+      if (this.mode === MODE.ERROR && 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
+    } = getConfigurationValue(this.agentIdentifier, 'session_replay');
+    this.waitForFlags(['sr']).then(_ref => {
+      let [flagOn] = _ref;
+      this.entitled = flagOn;
+      if (!this.entitled && this.recorder?.recording) {
+        this.abort(ABORT_REASONS.ENTITLEMENTS);
+        handle(SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/EnabledNotEntitled/Detected'], undefined, FEATURE_NAMES.metrics, this.ee);
+        return;
+      }
+      this.initializeRecording(Math.random() * 100 < error_sampling_rate, Math.random() * 100 < sampling_rate);
+    }).then(() => {
+      if (this.mode === MODE.OFF) args?.recorder?.stopRecording(); // stop any conservative preload recording launched by instrument
+      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) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/AutoStart/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
+    if (collect_fonts === true) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/CollectFonts/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
+    if (inline_stylesheet !== true) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/InlineStylesheet/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
+    if (inline_images === true) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/InlineImages/Modifed'], undefined, FEATURE_NAMES.metrics, this.ee);
+    if (mask_all_inputs !== true) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/MaskAllInputs/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
+    if (block_selector !== '[data-nr-block]') handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/BlockSelector/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
+    if (mask_text_selector !== '*') handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/MaskTextSelector/Modified'], undefined, FEATURE_NAMES.metrics, this.ee);
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/SamplingRate/Value', sampling_rate], undefined, FEATURE_NAMES.metrics, this.ee);
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/ErrorSamplingRate/Value', error_sampling_rate], undefined, FEATURE_NAMES.metrics, this.ee);
+    this.drain();
   }
   switchToFull() {
     this.mode = MODE.FULL;
@@ -197,6 +194,11 @@ export class Aggregate extends 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
@@ -389,7 +391,7 @@ export class Aggregate extends 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/esm/features/session_replay/constants.js

@@ -1,6 +1,10 @@
 import { MODE } from '../../common/session/constants';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 export const FEATURE_NAME = FEATURE_NAMES.sessionReplay;
+export const SR_EVENT_EMITTER_TYPES = {
+  RECORD: 'recordReplay',
+  PAUSE: 'pauseReplay'
+};
 export const AVG_COMPRESSION = 0.12;
 export const RRWEB_EVENT_TYPES = {
   DomContentLoaded: 0,