@newrelic/browser-agent 1.235.0 → 1.237.0

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

@@ -5,63 +5,53 @@
 
 import { handle } from '../../../common/event-emitter/handle';
 import { now } from '../../../common/timing/now';
-import { getOrSet } from '../../../common/util/get-or-set';
-import { wrapRaf, wrapTimer, wrapEvents, wrapXhr } from '../../../common/wrap';
-import './debug';
 import { InstrumentBase } from '../../utils/instrument-base';
-import { FEATURE_NAME, NR_ERR_PROP } from '../constants';
+import { FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { globalScope } from '../../../common/util/global-scope';
+import { globalScope } from '../../../common/constants/runtime';
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts';
-import { getRuntime } from '../../../common/config/config';
 import { stringify } from '../../../common/util/stringify';
+import { UncaughtError } from './uncaught-error';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
+  #seenErrors = new Set();
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
-    // skipNext counter to keep track of uncaught
-    // errors that will be the same as caught errors.
-    this.skipNext = 0;
     try {
       // this try-catch can be removed when IE11 is completely unsupported & gone
       this.removeOnAbort = new AbortController();
     } catch (e) {}
-    const thisInstrument = this;
-    thisInstrument.ee.on('fn-start', function (args, obj, methodName) {
-      if (thisInstrument.abortHandler) thisInstrument.skipNext += 1;
-    });
-    thisInstrument.ee.on('fn-err', function (args, obj, err) {
-      if (thisInstrument.abortHandler && !err[NR_ERR_PROP]) {
-        getOrSet(err, NR_ERR_PROP, function getVal() {
-          return true;
-        });
-        this.thrown = true;
-        handle('err', [err, now()], undefined, FEATURE_NAMES.jserrors, thisInstrument.ee);
-      }
-    });
-    thisInstrument.ee.on('fn-end', function () {
-      if (!thisInstrument.abortHandler) return;
-      if (!this.thrown && thisInstrument.skipNext > 0) thisInstrument.skipNext -= 1;
+
+    // Capture function errors early in case the spa feature is loaded
+    this.ee.on('fn-err', (args, obj, error) => {
+      if (!this.abortHandler || this.#seenErrors.has(error)) return;
+      this.#seenErrors.add(error);
+      handle('err', [this.#castError(error), now()], undefined, FEATURE_NAMES.jserrors, this.ee);
     });
-    thisInstrument.ee.on('internal-error', function (e) {
-      handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, thisInstrument.ee);
+    this.ee.on('internal-error', error => {
+      if (!this.abortHandler) return;
+      handle('ierr', [this.#castError(error), now(), true], undefined, FEATURE_NAMES.jserrors, this.ee);
     });
-
-    // Replace global error handler with our own.
-    this.origOnerror = globalScope.onerror;
-    globalScope.onerror = this.onerrorHandler.bind(this);
-    globalScope.addEventListener('unhandledrejection', e => {
-      /** rejections can contain data of any type -- this is an effort to keep the message human readable */
-      const err = castReasonToError(e.reason);
-      handle('err', [err, now(), false, {
+    globalScope.addEventListener('unhandledrejection', promiseRejectionEvent => {
+      if (!this.abortHandler) return;
+      handle('err', [this.#castPromiseRejectionEvent(promiseRejectionEvent), now(), false, {
         unhandledPromiseRejection: 1
       }], undefined, FEATURE_NAMES.jserrors, this.ee);
     }, eventListenerOpts(false, this.removeOnAbort?.signal));
-    wrapRaf(this.ee);
-    wrapTimer(this.ee);
-    wrapEvents(this.ee);
-    if (getRuntime(agentIdentifier).xhrWrappable) wrapXhr(this.ee);
+    globalScope.addEventListener('error', errorEvent => {
+      if (!this.abortHandler) return;
+
+      /**
+       * If the spa feature is loaded, errors may already have been captured in the `fn-err` listener above.
+       * This ensures those errors are not captured twice.
+       */
+      if (this.#seenErrors.has(errorEvent.error)) {
+        this.#seenErrors.delete(errorEvent.error);
+        return;
+      }
+      handle('err', [this.#castErrorEvent(errorEvent), now()], undefined, FEATURE_NAMES.jserrors, this.ee);
+    }, 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();
   }
@@ -69,65 +59,66 @@ export class Instrument extends InstrumentBase {
   /** Restoration and resource release tasks to be done if JS error loader is being aborted. Unwind changes to globals. */
   #abort() {
     this.removeOnAbort?.abort();
+    this.#seenErrors.clear();
     this.abortHandler = undefined; // weakly allow this abort op to run only once
   }
 
   /**
-   * FF and Android browsers do not provide error info to the 'error' event callback,
-   * so we must use window.onerror
-   * @param {string} message
-   * @param {string} filename
-   * @param {number} lineno
-   * @param {number} column
-   * @param {Error | *} errorObj
-   * @returns
+   * Any value can be used with the `throw` keyword. This function ensures that the value is
+   * either a proper Error instance or attempts to convert it to an UncaughtError instance.
+   * @param {any} error The value thrown
+   * @returns {Error|UncaughtError} The converted error instance
    */
-  onerrorHandler(message, filename, lineno, column, errorObj) {
-    if (typeof this.origOnerror === 'function') this.origOnerror(...arguments);
-    try {
-      if (this.skipNext) this.skipNext -= 1;else handle('err', [errorObj || new UncaughtException(message, filename, lineno), now()], undefined, FEATURE_NAMES.jserrors, this.ee);
-    } catch (e) {
+  #castError(error) {
+    if (error instanceof Error) {
+      return error;
+    }
+
+    /**
+     * The thrown value may contain a message property. If it does, try to treat the thrown
+     * value as an Error-like object.
+     */
+    if (typeof error?.message !== 'undefined') {
+      return new UncaughtError(error.message, error.filename || error.sourceURL, error.lineno || error.line, error.colno || error.col);
+    }
+    return new UncaughtError(typeof error === 'string' ? error : stringify(error));
+  }
+
+  /**
+   * Attempts to convert a PromiseRejectionEvent object to an Error object
+   * @param {PromiseRejectionEvent} unhandledRejectionEvent The unhandled promise rejection event
+   * @returns {Error} An Error object with the message as the casted reason
+   */
+  #castPromiseRejectionEvent(promiseRejectionEvent) {
+    let prefix = 'Unhandled Promise Rejection: ';
+    if (promiseRejectionEvent?.reason instanceof Error) {
       try {
-        handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, this.ee);
-      } catch (err) {
-        // do nothing
+        promiseRejectionEvent.reason.message = prefix + promiseRejectionEvent.reason.message;
+        return promiseRejectionEvent.reason;
+      } catch (e) {
+        return promiseRejectionEvent.reason;
       }
     }
-    return false; // maintain default behavior of the error event of Window
+    if (typeof promiseRejectionEvent.reason === 'undefined') return new UncaughtError(prefix);
+    const error = this.#castError(promiseRejectionEvent.reason);
+    error.message = prefix + error.message;
+    return error;
   }
-}
-
-/**
- *
- * @param {string} message
- * @param {string} filename
- * @param {number} lineno
- */
-function UncaughtException(message, filename, lineno) {
-  this.message = message || 'Uncaught error with no additional information';
-  this.sourceURL = filename;
-  this.line = lineno;
-}
 
-/**
- * Attempts to cast an unhandledPromiseRejection reason (reject(...)) to an Error object
- * @param {*} reason - The reason property from an unhandled promise rejection
- * @returns {Error} - An Error object with the message as the casted reason
- */
-function castReasonToError(reason) {
-  let prefix = 'Unhandled Promise Rejection: ';
-  if (reason instanceof Error) {
-    try {
-      reason.message = prefix + reason.message;
-      return reason;
-    } catch (e) {
-      return reason;
+  /**
+   * Attempts to convert an ErrorEvent object to an Error object
+   * @param {ErrorEvent} errorEvent The error event
+   * @returns {Error|UncaughtError} The error event converted to an Error object
+   */
+  #castErrorEvent(errorEvent) {
+    if (errorEvent.error instanceof Error) {
+      return errorEvent.error;
     }
-  }
-  if (typeof reason === 'undefined') return new Error(prefix);
-  try {
-    return new Error(prefix + stringify(reason));
-  } catch (err) {
-    return new Error(prefix);
+
+    /**
+     * Older browsers do not contain the `error` property on the ErrorEvent instance.
+     * https://caniuse.com/mdn-api_errorevent_error
+     */
+    return new UncaughtError(errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno);
   }
 }

package/dist/esm/features/jserrors/instrument/uncaught-error.js

@@ -0,0 +1,15 @@
+/**
+ * Represents an uncaught non Error type error. This class does
+ * not extend the Error class to prevent an invalid stack trace
+ * from being created. Use this class to cast thrown errors that
+ * do not use the Error class (strings, etc) to an object.
+ */
+export class UncaughtError {
+  constructor(message, filename, lineno, colno) {
+    this.name = 'UncaughtError';
+    this.message = message;
+    this.sourceURL = filename;
+    this.line = lineno;
+    this.column = colno;
+  }
+}

package/dist/esm/features/metrics/aggregate/framework-detection.js

@@ -1,4 +1,4 @@
-import { isBrowserScope } from '../../../common/util/global-scope';
+import { isBrowserScope } from '../../../common/constants/runtime';
 const FRAMEWORKS = {
   REACT: 'React',
   ANGULAR: 'Angular',

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

@@ -10,7 +10,7 @@ import { getRules, validateRules } from '../../../common/util/obfuscate';
 import { VERSION } from "../../../common/constants/env.npm";
 import { onDOMContentLoaded } from '../../../common/window/load';
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
-import { isBrowserScope } from '../../../common/util/global-scope';
+import { isBrowserScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { stringify } from '../../../common/util/stringify';
 import { endpointMap } from './endpoint-map';

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

@@ -11,7 +11,7 @@ import { cleanURL } from '../../../common/url/clean-url';
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
 import { FEATURE_NAME } from '../constants';
 import { drain } from '../../../common/drain/drain';
-import { isBrowserScope } from '../../../common/util/global-scope';
+import { isBrowserScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;

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

@@ -1,6 +1,6 @@
 import { handle } from '../../../common/event-emitter/handle';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { isiOS } from '../../../common/browser-version/ios-version';
+import { isiOS, globalScope, isBrowserScope } from '../../../common/constants/runtime';
 import { onTTFB } from 'web-vitals';
 import { addPT, addPN } from '../../../common/timing/nav-timing';
 import { stringify } from '../../../common/util/stringify';
@@ -9,7 +9,6 @@ import { getConfigurationValue, getInfo, getRuntime } from '../../../common/conf
 import { Harvest } from '../../../common/harvest/harvest';
 import * as CONSTANTS from '../constants';
 import { getActivatedFeaturesFlags } from './initialized-features';
-import { globalScope, isBrowserScope } from '../../../common/util/global-scope';
 import { drain } from '../../../common/drain/drain';
 import { activateFeatures } from '../../../common/util/feature-flags';
 import { warn } from '../../../common/util/console';

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

@@ -1,4 +1,5 @@
 import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { gosNREUM } from '../../../common/window/nreum';
 
 /**
  * Get an array of flags required by downstream (NR UI) based on the features initialized in this agent
@@ -8,25 +9,28 @@ import { FEATURE_NAMES } from '../../../loaders/features/features';
  */
 export function getActivatedFeaturesFlags(agentId) {
   const flagArr = [];
-  Object.keys(newrelic.initializedAgents[agentId].features).forEach(featName => {
-    switch (featName) {
-      case FEATURE_NAMES.ajax:
-        flagArr.push('xhr');
-        break;
-      case FEATURE_NAMES.jserrors:
-        flagArr.push('err');
-        break;
-      case FEATURE_NAMES.pageAction:
-        flagArr.push('ins');
-        break;
-      case FEATURE_NAMES.sessionTrace:
-        flagArr.push('stn');
-        break;
-      case FEATURE_NAMES.spa:
-        flagArr.push('spa');
-        break;
-    }
-  });
+  const newrelic = gosNREUM();
+  try {
+    Object.keys(newrelic.initializedAgents[agentId].features).forEach(featName => {
+      switch (featName) {
+        case FEATURE_NAMES.ajax:
+          flagArr.push('xhr');
+          break;
+        case FEATURE_NAMES.jserrors:
+          flagArr.push('err');
+          break;
+        case FEATURE_NAMES.pageAction:
+          flagArr.push('ins');
+          break;
+        case FEATURE_NAMES.sessionTrace:
+          flagArr.push('stn');
+          break;
+        case FEATURE_NAMES.spa:
+          flagArr.push('spa');
+          break;
+      }
+    });
+  } catch (e) {}
   return flagArr;
 }
 

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

@@ -1,5 +1,5 @@
 import { handle } from '../../../common/event-emitter/handle';
-import { isiOS } from '../../../common/browser-version/ios-version';
+import { isiOS } from '../../../common/constants/runtime';
 import { InstrumentBase } from '../../utils/instrument-base';
 import * as CONSTANTS from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';

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

@@ -6,7 +6,7 @@
 import { onFCP, onFID, onLCP, onCLS, onINP } from 'web-vitals';
 import { onFirstPaint } from '../first-paint';
 import { onLongTask } from '../long-tasks';
-import { iOS_below16 } from '../../../common/browser-version/ios-version';
+import { iOS_below16 } from '../../../common/constants/runtime';
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
 import { mapOwn } from '../../../common/util/map-own';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
@@ -232,9 +232,7 @@ export class Aggregate extends AggregateBase {
   }
   onHarvestFinished(result) {
     if (result.retry && this.timingsSent.length > 0) {
-      for (var i = 0; i < this.timingsSent.length; i++) {
-        this.timings.push(this.timingsSent[i]);
-      }
+      this.timings.unshift(...this.timingsSent);
       this.timingsSent = [];
     }
   }

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

@@ -9,7 +9,7 @@ import { windowAddEventListener } from '../../../common/event-listener/event-lis
 import { now } from '../../../common/timing/now';
 import { InstrumentBase } from '../../utils/instrument-base';
 import { FEATURE_NAME } from '../constants';
-import { isBrowserScope } from '../../../common/util/global-scope';
+import { isBrowserScope } from '../../../common/constants/runtime';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {

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

@@ -19,6 +19,7 @@ import { getConfigurationValue, getInfo, getRuntime } from '../../../common/conf
 import { SESSION_EVENTS, MODE } from '../../../common/session/session-entity';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { sharedChannel } from '../../../common/constants/shared-channel';
+import { obj as encodeObj } from '../../../common/url/encode';
 
 // would be better to get this dynamically in some way
 export const RRWEB_VERSION = '2.0.0-alpha.8';
@@ -29,8 +30,12 @@ let recorder, gzipper, u8;
 export const MAX_PAYLOAD_SIZE = 1000000;
 /** Unloading caps around 64kb */
 export const IDEAL_PAYLOAD_SIZE = 64000;
-/** Interval between forcing new full snapshots in "error" mode */
-const CHECKOUT_MS = 30000;
+/** Interval between forcing new full snapshots -- 30 seconds in error mode, 5 minutes in full mode */
+const CHECKOUT_MS = {
+  [MODE.ERROR]: 30000,
+  [MODE.FULL]: 300000,
+  [MODE.OFF]: 0
+};
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
@@ -62,6 +67,12 @@ export class Aggregate extends AggregateBase {
     /** Payload metadata -- Should indicate that the payload being sent contains an error.  Used for query/filter purposes in UI */
     this.hasError = false;
 
+    /** Payload metadata -- Should indicate when a replay blob started recording.  Resets each time a harvest occurs. */
+    this.timestamp = {
+      first: undefined,
+      last: undefined
+    };
+
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     this.payloadBytesEstimation = 0;
     const shouldSetup = getConfigurationValue(agentIdentifier, 'privacy.cookies_enabled') === true && getConfigurationValue(agentIdentifier, 'session_trace.enabled') === true;
@@ -85,7 +96,7 @@ export class Aggregate extends AggregateBase {
       });
 
       // Bespoke logic for new endpoint.  This will change as downstream dependencies become solidified.
-      this.scheduler = new HarvestScheduler('blob', {
+      this.scheduler = new HarvestScheduler('browser/blobs', {
         onFinished: this.onHarvestFinished.bind(this),
         retryDelay: this.harvestTimeSeconds,
         getPayload: this.prepareHarvest.bind(this),
@@ -105,10 +116,9 @@ export class Aggregate extends AggregateBase {
             this.stopRecording();
             this.startRecording();
             this.scheduler.startTimer(this.harvestTimeSeconds);
-            const {
-              session
-            } = getRuntime(this.agentIdentifier);
-            session.state.sessionReplay = this.mode;
+            this.syncWithSessionManager({
+              sessionReplay: this.mode
+            });
           }
         }
       }, this.featureName, this.ee);
@@ -181,17 +191,18 @@ export class Aggregate extends AggregateBase {
     }
     this.startRecording();
     this.isFirstChunk = !!session.isNew;
-    session.state.sessionReplay = this.mode;
+    this.syncWithSessionManager({
+      sessionReplay: this.mode
+    });
   }
   prepareHarvest() {
-    if (this.events.length === 0) return;
+    if (this.events.length === 0 || this.mode !== MODE.FULL && !this.blocked) return;
     const payload = this.getHarvestContents();
     if (this.shouldCompress) {
       payload.body = gzipper(u8(stringify(payload.body)));
       this.scheduler.opts.gzip = true;
     } else {
       this.scheduler.opts.gzip = false;
-      delete payload.qs.content_encoding;
     }
     // TODO -- Gracefully handle the buffer for retries.
     this.clearBuffer();
@@ -202,25 +213,28 @@ export class Aggregate extends AggregateBase {
     const info = getInfo(this.agentIdentifier);
     return {
       qs: {
-        protocol_version: '0',
-        content_encoding: 'gzip',
-        browser_monitoring_key: info.licenseKey
-      },
-      body: {
+        browser_monitoring_key: info.licenseKey,
         type: 'SessionReplay',
-        appId: Number(info.applicationID),
-        timestamp: Date.now(),
-        blob: JSON.stringify(this.events),
-        // this needs to be a stringified JSON array of rrweb nodes
-        attributes: {
+        app_id: info.applicationID,
+        protocol_version: '0',
+        attributes: encodeObj({
+          ...(this.shouldCompress && {
+            content_encoding: 'gzip'
+          }),
+          'replay.firstTimestamp': this.timestamp.first,
+          'replay.lastTimestamp': this.timestamp.last,
+          'replay.durationMs': this.timestamp.last - this.timestamp.first,
+          agentVersion: agentRuntime.version,
           session: agentRuntime.session.state.value,
           hasSnapshot: this.hasSnapshot,
           hasError: this.hasError,
-          agentVersion: agentRuntime.version,
           isFirstChunk: this.isFirstChunk,
+          decompressedBytes: this.payloadBytesEstimation,
           'nr.rrweb.version': RRWEB_VERSION
-        }
-      }
+        }, MAX_PAYLOAD_SIZE - this.payloadBytesEstimation).substring(1) // remove the leading '&'
+      },
+
+      body: this.events
     };
   }
   onHarvestFinished(result) {
@@ -238,6 +252,7 @@ export class Aggregate extends AggregateBase {
     this.hasSnapshot = false;
     this.hasError = false;
     this.payloadBytesEstimation = 0;
+    this.clearTimestamps();
   }
 
   /** Begin recording using configured recording lib */
@@ -246,6 +261,7 @@ export class Aggregate extends AggregateBase {
       warn('Recording library was never imported');
       return this.abort();
     }
+    this.recording = true;
     const {
       blockClass,
       ignoreClass,
@@ -255,7 +271,6 @@ export class Aggregate extends AggregateBase {
       maskTextSelector,
       maskAllInputs
     } = getConfigurationValue(this.agentIdentifier, 'session_replay');
-    this.hasSnapshot = true;
     // set up rrweb configurations for maximum privacy --
     // https://newrelic.atlassian.net/wiki/spaces/O11Y/pages/2792293280/2023+02+28+Browser+-+Session+Replay#Configuration-options
     const stop = recorder({
@@ -267,11 +282,8 @@ export class Aggregate extends AggregateBase {
       maskInputOptions,
       maskTextSelector,
       maskAllInputs,
-      ...(this.mode === MODE.ERROR && {
-        checkoutEveryNms: CHECKOUT_MS
-      })
+      checkoutEveryNms: CHECKOUT_MS[this.mode]
     });
-    this.recording = true;
     this.stopRecording = () => {
       this.recording = false;
       stop();
@@ -296,12 +308,14 @@ export class Aggregate extends AggregateBase {
       // we are still waiting for an error to throw, so keep wiping the buffer over time
       this.clearBuffer();
     }
+    this.setTimestamps(event);
+    if (event.type === 2) this.hasSnapshot = true;
     this.events.push(event);
     this.payloadBytesEstimation += eventBytes;
 
     // We are making an effort to try to keep payloads manageable for unloading.  If they reach the unload limit before their interval,
     // it will send immediately.  This often happens on the first snapshot, which can be significantly larger than the other payloads.
-    if (payloadSize > IDEAL_PAYLOAD_SIZE) {
+    if (payloadSize > IDEAL_PAYLOAD_SIZE && this.mode !== MODE.ERROR) {
       // if we've made it to the ideal size of ~64kb before the interval timer, we should send early.
       this.scheduler.runHarvest();
     }
@@ -311,7 +325,17 @@ export class Aggregate extends AggregateBase {
   takeFullSnapshot() {
     if (!recorder) return;
     recorder.takeFullSnapshot();
-    this.hasSnapshot = true;
+  }
+  setTimestamps(rrwebEvent) {
+    if (!rrwebEvent) return;
+    if (!this.timestamp.first) this.timestamp.first = rrwebEvent.timestamp;
+    this.timestamp.last = rrwebEvent.timestamp;
+  }
+  clearTimestamps() {
+    this.timestamp = {
+      first: undefined,
+      last: undefined
+    };
   }
 
   /** Estimate the payload size */
@@ -326,11 +350,11 @@ export class Aggregate extends AggregateBase {
     this.blocked = true;
     this.mode = MODE.OFF;
     this.stopRecording();
+    this.syncWithSessionManager({
+      sessionReplay: this.mode
+    });
+    this.clearTimestamps();
     this.ee.emit('REPLAY_ABORTED');
-    const {
-      session
-    } = getRuntime(this.agentIdentifier);
-    session.state.sessionReplay = this.mode;
   }
 
   /** Extensive research has yielded about an 88% compression factor on these payloads.
@@ -341,4 +365,11 @@ export class Aggregate extends AggregateBase {
     if (this.shouldCompress) return data * AVG_COMPRESSION;
     return data;
   }
+  syncWithSessionManager() {
+    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const {
+      session
+    } = getRuntime(this.agentIdentifier);
+    session.write(state);
+  }
 }

package/dist/esm/features/session_replay/replay-mode.js

@@ -15,8 +15,8 @@ export async function getSessionReplayMode(agentId) {
     const newrelic = gosNREUM();
     // Should be enabled by configuration and using an agent build that includes it (via checking that the instrument class was initialized).
     if (getConfigurationValue(agentId, 'session_replay.enabled') && typeof newrelic.initializedAgents[agentId].features.session_replay === 'object') {
-      await newrelic.initializedAgents[agentId].features.session_replay.onAggregateImported; // if Replay could not initialize, this throws a (uncaught) rejection
-      return await sharedChannel.sessionReplayInitialized; // wait for replay to determine which mode it's after running its sampling logic
+      const srInitialized = await newrelic.initializedAgents[agentId].features.session_replay.onAggregateImported;
+      if (srInitialized) return await sharedChannel.sessionReplayInitialized; // wait for replay to determine which mode it's after running its sampling logic
     }
   } catch (e) {/* exception ==> off */}
   return MODE.OFF; // at any step of the way s.t. SR cannot be on by implication or is explicitly off

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

@@ -109,8 +109,8 @@ export class Aggregate extends AggregateBase {
           sessionTraceMode: MODE.OFF
         });
         operationalGate.permanentlyDecide(false);
-        this.#scheduler?.stopTimer(true);
         if (mostRecentModeKnown === MODE.FULL) this.#scheduler?.runHarvest(); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
+        this.#scheduler?.stopTimer(true); // the 'true' arg here will forcibly block any future call to runHarvest, so the last runHarvest above must be prior
         this.#scheduler = null;
       };
 
@@ -136,9 +136,8 @@ export class Aggregate extends AggregateBase {
           this.ee.on(SESSION_EVENTS.PAUSE, () => mostRecentModeKnown = sessionEntity.state.sessionTraceMode);
           if (!sessionEntity.isNew) {
             // inherit the same mode as existing session's Trace
-            const existingTraceMode = mostRecentModeKnown = sessionEntity.state.sessionTraceMode;
-            if (existingTraceMode === MODE.OFF) this.isStandalone = true;
-            controlTraceOp(existingTraceMode);
+            if (sessionEntity.state.sessionReplay === MODE.OFF) this.isStandalone = true;
+            controlTraceOp(mostRecentModeKnown = sessionEntity.state.sessionTraceMode);
           } else {
             // for new sessions, see the truth table associated with NEWRELIC-8662 wrt the new Trace behavior under session management
             const replayMode = await getSessionReplayMode(agentIdentifier);

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

@@ -8,7 +8,7 @@ import { now } from '../../../common/timing/now';
 import { InstrumentBase } from '../../utils/instrument-base';
 import * as CONSTANTS from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { isBrowserScope } from '../../../common/util/global-scope';
+import { isBrowserScope } from '../../../common/constants/runtime';
 const {
   BST_RESOURCE,
   RESOURCE,

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

@@ -619,7 +619,7 @@ export class Aggregate extends AggregateBase {
     function onHarvestFinished(result) {
       if (result.sent && result.retry && state.interactionsSent.length > 0) {
         state.interactionsSent.forEach(function (interaction) {
-          state.interactionsToHarvest.push(interaction);
+          state.interactionsToHarvest.unshift(interaction);
         });
         state.interactionsSent = [];
       }

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

@@ -8,7 +8,7 @@ import { InstrumentBase } from '../../utils/instrument-base';
 import { getRuntime } from '../../../common/config/config';
 import { now } from '../../../common/timing/now';
 import * as CONSTANTS from '../constants';
-import { isBrowserScope } from '../../../common/util/global-scope';
+import { isBrowserScope } from '../../../common/constants/runtime';
 const {
   FEATURE_NAME,
   START,