@newrelic/browser-agent 1.236.0 → 1.237.0

package/src/features/jserrors/instrument/index.js

@@ -5,64 +5,60 @@
 
 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/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, auto = 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', (promiseRejectionEvent) => {
+      if (!this.abortHandler) return
 
-    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, { unhandledPromiseRejection: 1 }], undefined, FEATURE_NAMES.jserrors, this.ee)
+      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()
@@ -71,67 +67,75 @@ 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)
+  #castError (error) {
+    if (error instanceof Error) {
+      return error
+    }
 
-    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) {
-      try {
-        handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, this.ee)
-      } catch (err) {
-        // do nothing
-      }
+    /**
+     * 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 false // maintain default behavior of the error event of Window
+
+    return new UncaughtError(typeof error === 'string' ? error : stringify(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 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: '
 
-/**
- * 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
+    if (promiseRejectionEvent?.reason instanceof Error) {
+      try {
+        promiseRejectionEvent.reason.message = prefix + promiseRejectionEvent.reason.message
+        return promiseRejectionEvent.reason
+      } catch (e) {
+        return promiseRejectionEvent.reason
+      }
     }
+
+    if (typeof promiseRejectionEvent.reason === 'undefined') return new UncaughtError(prefix)
+
+    const error = this.#castError(promiseRejectionEvent.reason)
+    error.message = prefix + error.message
+    return error
   }
-  if (typeof reason === 'undefined') return new Error(prefix)
-  try {
-    return new Error(prefix + stringify(reason))
-  } catch (err) {
-    return new Error(prefix)
+
+  /**
+   * 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
+    }
+
+    /**
+     * 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/src/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/src/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,21 +9,24 @@ import { FEATURE_NAMES } from '../../../loaders/features/features'
  */
 export function getActivatedFeaturesFlags (agentId) {
   const flagArr = []
+  const newrelic = gosNREUM()
 
-  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
-    }
-  })
+  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/src/features/session_replay/aggregate/index.component-test.js

@@ -40,6 +40,14 @@ const agentIdentifier = 'abcd'
 const info = { licenseKey: 1234, applicationID: 9876 }
 const init = { session_replay: { enabled: true, sampleRate: 1, errorSampleRate: 0 } }
 
+const anyQuery = {
+  browser_monitoring_key: info.licenseKey,
+  type: 'SessionReplay',
+  app_id: Number(info.applicationID),
+  protocol_version: '0',
+  attributes: expect.any(String)
+}
+
 describe('Session Replay', () => {
   beforeEach(async () => {
     primeSessionAndReplay()
@@ -221,28 +229,11 @@ describe('Session Replay', () => {
       await wait(1)
       const harvestContents = sr.getHarvestContents()
       // query attrs
-      expect(harvestContents.qs).toMatchObject({
-        protocol_version: '0',
-        content_encoding: 'gzip',
-        browser_monitoring_key: info.licenseKey
-      })
+      expect(harvestContents.qs).toMatchObject(anyQuery)
 
-      expect(harvestContents.body).toMatchObject({
-        type: 'SessionReplay',
-        appId: info.applicationID,
-        timestamp: expect.any(Number),
-        blob: expect.any(String),
-        attributes: {
-          session: session.state.value,
-          hasSnapshot: expect.any(Boolean),
-          hasError: expect.any(Boolean),
-          agentVersion: expect.any(String),
-          isFirstChunk: expect.any(Boolean),
-          'nr.rrweb.version': expect.any(String)
-        }
-      })
+      expect(harvestContents.body).toEqual(expect.any(Array))
 
-      expect(JSON.parse(harvestContents.body.blob).length).toBeGreaterThan(0)
+      expect(harvestContents.body.length).toBeGreaterThan(0)
     })
   })
 
@@ -253,26 +244,10 @@ describe('Session Replay', () => {
       sr.ee.emit('rumresp-sr', [true])
       await wait(1)
       const [harvestContents] = sr.prepareHarvest()
-      expect(harvestContents.qs).toMatchObject({
-        protocol_version: '0',
-        content_encoding: 'gzip',
-        browser_monitoring_key: info.licenseKey
-      })
+      expect(harvestContents.qs).toMatchObject(anyQuery)
+      expect(harvestContents.qs.attributes.includes('content_encoding=gzip')).toEqual(true)
       expect(harvestContents.body).toEqual(expect.any(Uint8Array))
-      expect(JSON.parse(strFromU8(gunzipSync(harvestContents.body)))).toMatchObject({
-        type: 'SessionReplay',
-        appId: info.applicationID,
-        timestamp: expect.any(Number),
-        blob: expect.any(String),
-        attributes: {
-          session: session.state.value,
-          hasSnapshot: expect.any(Boolean),
-          hasError: expect.any(Boolean),
-          agentVersion: expect.any(String),
-          isFirstChunk: expect.any(Boolean),
-          'nr.rrweb.version': expect.any(String)
-        }
-      })
+      expect(JSON.parse(strFromU8(gunzipSync(harvestContents.body)))).toMatchObject(expect.any(Array))
     })
 
     test('Uncompressed payload is provided to harvester', async () => {
@@ -289,24 +264,10 @@ describe('Session Replay', () => {
       const [harvestContents] = sr.prepareHarvest()
       expect(harvestContents.qs).toMatchObject({
         protocol_version: '0',
-        // content_encoding is omitted when the payload is not compressed
         browser_monitoring_key: info.licenseKey
       })
-      expect(harvestContents.qs.content_encoding).toBeUndefined()
-      expect(harvestContents.body).toMatchObject({
-        type: 'SessionReplay',
-        appId: info.applicationID,
-        timestamp: expect.any(Number),
-        blob: expect.any(String),
-        attributes: {
-          session: session.state.value,
-          hasSnapshot: expect.any(Boolean),
-          hasError: expect.any(Boolean),
-          agentVersion: expect.any(String),
-          isFirstChunk: expect.any(Boolean),
-          'nr.rrweb.version': expect.any(String)
-        }
-      })
+      expect(harvestContents.qs.attributes.includes('content_encoding')).toEqual(false)
+      expect(harvestContents.body).toEqual(expect.any(Array))
     })
 
     test('Clears the event buffer when staged for harvesting', async () => {
@@ -363,6 +324,6 @@ function wait (ms = 0) {
 
 function primeSessionAndReplay (sess = new SessionEntity({ agentIdentifier, key: 'SESSION', storage: new LocalMemory() })) {
   session = sess
-  configure(agentIdentifier, { info, runtime: { session } }, 'test', true)
+  configure(agentIdentifier, { info, runtime: { session }, init: {} }, 'test', true)
   sr = new SessionReplayAgg(agentIdentifier, new Aggregator({}))
 }

package/src/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'
@@ -31,8 +32,8 @@ 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
@@ -65,6 +66,9 @@ 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
 
@@ -91,7 +95,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),
@@ -112,8 +116,7 @@ export class Aggregate extends AggregateBase {
             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)
@@ -187,11 +190,11 @@ export class Aggregate extends AggregateBase {
 
     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) {
@@ -199,7 +202,6 @@ export class Aggregate extends AggregateBase {
       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()
@@ -211,24 +213,25 @@ 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
     }
   }
 
@@ -248,6 +251,7 @@ export class Aggregate extends AggregateBase {
     this.hasSnapshot = false
     this.hasError = false
     this.payloadBytesEstimation = 0
+    this.clearTimestamps()
   }
 
   /** Begin recording using configured recording lib */
@@ -256,8 +260,8 @@ export class Aggregate extends AggregateBase {
       warn('Recording library was never imported')
       return this.abort()
     }
+    this.recording = true
     const { blockClass, ignoreClass, maskTextClass, blockSelector, maskInputOptions, 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({
@@ -269,11 +273,9 @@ 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()
@@ -299,12 +301,15 @@ export class Aggregate extends AggregateBase {
       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()
     }
@@ -314,7 +319,16 @@ 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 */
@@ -328,9 +342,9 @@ 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 +355,9 @@ export class Aggregate extends AggregateBase {
     if (this.shouldCompress) return data * AVG_COMPRESSION
     return data
   }
+
+  syncWithSessionManager (state = {}) {
+    const { session } = getRuntime(this.agentIdentifier)
+    session.write(state)
+  }
 }

package/src/features/session_trace/aggregate/index.js

@@ -97,8 +97,8 @@ export class Aggregate extends AggregateBase {
       const stopTracePerm = () => {
         if (sessionEntity.state.sessionTraceMode !== MODE.OFF) sessionEntity.write({ 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
       }
 
@@ -122,9 +122,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)
             if (replayMode === MODE.OFF) this.isStandalone = true // without SR, Traces are still subject to old harvest limits

package/src/features/utils/instrument-base.js

@@ -10,7 +10,7 @@ import { onWindowLoad } from '../../common/window/load'
 import { isBrowserScope } from '../../common/constants/runtime'
 import { warn } from '../../common/util/console'
 import { FEATURE_NAMES } from '../../loaders/features/features'
-import { getConfigurationValue } from '../../common/config/config'
+import { getConfigurationValue, originals } from '../../common/config/config'
 
 /**
  * Base class for instrumenting a feature.
@@ -55,7 +55,7 @@ export class InstrumentBase extends FeatureBase {
   importAggregator (argsObjFromInstrument = {}) {
     if (this.featAggregate || !this.auto) return
     const enableSessionTracking = isBrowserScope && getConfigurationValue(this.agentIdentifier, 'privacy.cookies_enabled') === true
-    let loadedSuccessfully, loadFailed
+    let loadedSuccessfully
     this.onAggregateImported = new Promise(resolve => {
       loadedSuccessfully = resolve
     })
@@ -78,6 +78,7 @@ export class InstrumentBase extends FeatureBase {
       try {
         if (!this.shouldImportAgg(this.featureName, session)) {
           drain(this.agentIdentifier, this.featureName)
+          loadedSuccessfully(false) // aggregate module isn't loaded at all
           return
         }
         const { lazyFeatureLoader } = await import(/* webpackChunkName: "lazy-feature-loader" */ './lazy-feature-loader')
@@ -105,15 +106,11 @@ export class InstrumentBase extends FeatureBase {
  * @returns
  */
   shouldImportAgg (featureName, session) {
-  // if this isnt the FIRST load of a session AND
-  // we are not actively recording SR... DO NOT run the aggregator
-  // session replay samples can only be decided on the first load of a session
-  // session replays can continue if in progress
     if (featureName === FEATURE_NAMES.sessionReplay) {
-      if (getConfigurationValue(this.agentIdentifier, 'session_trace.enabled') === false) return false
-      return !!session?.isNew || !!session?.state.sessionReplay
+      if (!originals.MO) return false // Session Replay cannot work without Mutation Observer
+      if (getConfigurationValue(this.agentIdentifier, 'session_trace.enabled') === false) return false // Session Replay as of now is tightly coupled with Session Trace in the UI
+      return !!session?.isNew || !!session?.state.sessionReplay // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
     }
-    // todo -- add case like above for session trace
     return true
   }
 }