@newrelic/browser-agent 1.255.0 → 1.256.0

package/src/common/timing/time-keeper.js

@@ -1,5 +1,3 @@
-import { globalScope } from '../constants/runtime'
-
 /**
  * Class used to adjust the timestamp of harvested data to New Relic server time. This
  * is done by tracking the performance timings of the RUM call and applying a calculation
@@ -33,7 +31,7 @@ export class TimeKeeper {
   #ready = false
 
   constructor () {
-    this.#originTime = globalScope.performance.timeOrigin || globalScope.performance.timing.navigationStart
+    this.#originTime = Date.now() - performance.now()
   }
 
   get ready () {

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

@@ -38,10 +38,13 @@ export class Aggregate extends AggregateBase {
     this.bufferedErrorsUnderSpa = {}
     this.currentBody = undefined
     this.errorOnPage = false
+    this.replayAborted = false
 
     // this will need to change to match whatever ee we use in the instrument
     this.ee.on('interactionDone', (interaction, wasSaved) => this.onInteractionDone(interaction, wasSaved))
 
+    this.ee.on('REPLAY_ABORTED', () => { this.replayAborted = true })
+
     register('err', (...args) => this.storeError(...args), this.featureName, this.ee)
     register('ierr', (...args) => this.storeError(...args), this.featureName, this.ee)
     register('softNavFlush', (interactionId, wasFinished, softNavAttrs) =>
@@ -78,9 +81,16 @@ export class Aggregate extends AggregateBase {
       payload.qs.ri = releaseIds
     }
 
-    if (body && body.err && body.err.length && !this.errorOnPage) {
-      payload.qs.pve = '1'
-      this.errorOnPage = true
+    if (body && body.err && body.err.length) {
+      if (this.replayAborted) {
+        body.err.forEach((e) => {
+          delete e.params?.hasReplay
+        })
+      }
+      if (!this.errorOnPage) {
+        payload.qs.pve = '1'
+        this.errorOnPage = true
+      }
     }
     return payload
   }
@@ -133,7 +143,7 @@ export class Aggregate extends AggregateBase {
     return canonicalStackString
   }
 
-  storeError (err, time, internal, customAttributes) {
+  storeError (err, time, internal, customAttributes, hasReplay) {
     // are we in an interaction
     time = time || now()
     const agentRuntime = getRuntime(this.agentIdentifier)
@@ -189,7 +199,7 @@ export class Aggregate extends AggregateBase {
       this.pageviewReported[bucketHash] = true
     }
 
-    if (agentRuntime?.session?.state?.sessionReplayMode) params.hasReplay = true
+    if (hasReplay && !this.replayAborted) params.hasReplay = hasReplay
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash]
     params.timestamp = this.observedAt[bucketHash]
 
@@ -199,7 +209,6 @@ export class Aggregate extends AggregateBase {
     // 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
 

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

@@ -12,11 +12,13 @@ import { eventListenerOpts } from '../../../common/event-listener/event-listener
 import { stringify } from '../../../common/util/stringify'
 import { UncaughtError } from './uncaught-error'
 import { now } from '../../../common/timing/now'
+import { SR_EVENT_EMITTER_TYPES } from '../../session_replay/constants'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
 
   #seenErrors = new Set()
+  #replayRunning = false
 
   constructor (agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto)
@@ -36,13 +38,16 @@ export class Instrument extends InstrumentBase {
 
     this.ee.on('internal-error', (error) => {
       if (!this.abortHandler) return
-      handle('ierr', [this.#castError(error), now(), true], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('ierr', [this.#castError(error), now(), true, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
+    })
+
+    this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, (isRunning) => {
+      this.#replayRunning = isRunning
     })
 
     globalScope.addEventListener('unhandledrejection', (promiseRejectionEvent) => {
       if (!this.abortHandler) return
-
-      handle('err', [this.#castPromiseRejectionEvent(promiseRejectionEvent), now(), false, { unhandledPromiseRejection: 1 }], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('err', [this.#castPromiseRejectionEvent(promiseRejectionEvent), now(), false, { unhandledPromiseRejection: 1 }, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee)
     }, eventListenerOpts(false, this.removeOnAbort?.signal))
 
     globalScope.addEventListener('error', (errorEvent) => {
@@ -57,7 +62,7 @@ export class Instrument extends InstrumentBase {
         return
       }
 
-      handle('err', [this.#castErrorEvent(errorEvent), now()], undefined, FEATURE_NAMES.jserrors, this.ee)
+      handle('err', [this.#castErrorEvent(errorEvent), now(), false, {}, this.#replayRunning], 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

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

@@ -28,9 +28,12 @@ import { stringify } from '../../../common/util/stringify'
 import { stylesheetEvaluator } from '../shared/stylesheet-evaluator'
 import { deregisterDrain } from '../../../common/drain/drain'
 import { now } from '../../../common/timing/now'
+import { buildNRMetaNode } from '../shared/utils'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
+  mode = MODE.OFF
+
   // pass the recorder into the aggregator
   constructor (agentIdentifier, aggregator, args) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
@@ -44,9 +47,6 @@ export class Aggregate extends AggregateBase {
     this.gzipper = undefined
     /** populated with the u8 string lib async */
     this.u8 = undefined
-    /** the mode to start in.  Defaults to off */
-    const { session } = getRuntime(this.agentIdentifier)
-    this.mode = session.state.sessionReplayMode || MODE.OFF
 
     /** set by BCS response */
     this.entitled = false
@@ -54,13 +54,13 @@ export class Aggregate extends AggregateBase {
     this.timeKeeper = undefined
 
     this.recorder = args?.recorder
-    if (this.recorder) this.recorder.parent = this
+    this.preloaded = !!this.recorder
+    this.errorNoticed = args?.errorNoticed || false
 
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, 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)
     })
 
@@ -104,17 +104,6 @@ export class Aggregate extends AggregateBase {
       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(([flagOn]) => {
@@ -150,6 +139,14 @@ export class Aggregate extends AggregateBase {
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/ErrorSamplingRate/Value', error_sampling_rate], undefined, FEATURE_NAMES.metrics, this.ee)
   }
 
+  handleError (e) {
+    if (this.recorder) this.recorder.currentBufferTarget.hasError = true
+    // run once
+    if (this.mode === MODE.ERROR && globalScope?.document.visibilityState === 'visible') {
+      this.switchToFull()
+    }
+  }
+
   switchToFull () {
     this.mode = MODE.FULL
     // if the error was noticed AFTER the recorder was already imported....
@@ -210,12 +207,13 @@ export class Aggregate extends AggregateBase {
       } catch (err) {
         return this.abort(ABORT_REASONS.IMPORT)
       }
+    } else {
+      this.recorder.parent = this
     }
 
     // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
-    if (this.mode === MODE.ERROR && this.errorNoticed) {
-      this.mode = MODE.FULL
-    }
+    if (this.mode === MODE.ERROR && this.errorNoticed) this.mode = MODE.FULL
+    if (!this.preloaded) this.ee.on('err', e => this.handleError(e))
 
     // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
     // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
@@ -255,16 +253,29 @@ export class Aggregate extends AggregateBase {
       return
     }
 
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/Harvest/Attempts'], undefined, FEATURE_NAMES.metrics, this.ee)
+
     let len = 0
     if (!!this.gzipper && !!this.u8) {
-      payload.body = this.gzipper(this.u8(`[${payload.body.map(e => {
-        if (e.__serialized) return e.__serialized
-        return stringify(e)
+      payload.body = this.gzipper(this.u8(`[${payload.body.map(({ __serialized, ...e }) => {
+        if (e.__newrelic && __serialized) return __serialized
+        const output = { ...e }
+        if (!output.__newrelic) {
+          output.__newrelic = buildNRMetaNode(e.timestamp, this.timeKeeper)
+          output.timestamp = this.timeKeeper.correctAbsoluteTimestamp(e.timestamp)
+        }
+        return stringify(output)
       }).join(',')}]`))
       len = payload.body.length
       this.scheduler.opts.gzip = true
     } else {
-      payload.body = payload.body.map(({ __serialized, ...node }) => node)
+      payload.body = payload.body.map(({ __serialized, ...node }) => {
+        if (node.__newrelic) return node
+        const output = { ...node }
+        output.__newrelic = buildNRMetaNode(node.timestamp, this.timeKeeper)
+        output.timestamp = this.timeKeeper.correctAbsoluteTimestamp(node.timestamp)
+        return output
+      })
       len = stringify(payload.body).length
       this.scheduler.opts.gzip = false
     }
@@ -281,6 +292,12 @@ export class Aggregate extends AggregateBase {
     return [payload]
   }
 
+  getCorrectedTimestamp (node) {
+    if (!node.timestamp) return
+    if (node.__newrelic) return node.timestamp
+    return this.timeKeeper.correctAbsoluteTimestamp(node.timestamp)
+  }
+
   getHarvestContents (recorderEvents) {
     recorderEvents ??= this.recorder.getEvents()
     let events = recorderEvents.events
@@ -308,8 +325,8 @@ export class Aggregate extends AggregateBase {
 
     const relativeNow = now()
 
-    const firstEventTimestamp = events[0]?.timestamp // from rrweb node
-    const lastEventTimestamp = events[events.length - 1]?.timestamp // from rrweb node
+    const firstEventTimestamp = this.getCorrectedTimestamp(events[0]) // from rrweb node
+    const lastEventTimestamp = this.getCorrectedTimestamp(events[events.length - 1]) // from rrweb node
     const firstTimestamp = firstEventTimestamp || this.timeKeeper.correctAbsoluteTimestamp(recorderEvents.cycleTimestamp) // from rrweb node || from when the harvest cycle started
     const lastTimestamp = lastEventTimestamp || this.timeKeeper.convertRelativeTimestamp(relativeNow)
 
@@ -341,6 +358,7 @@ export class Aggregate extends AggregateBase {
           invalidStylesheetsDetected: stylesheetEvaluator.invalidStylesheetsDetected,
           inlinedAllStylesheets: recorderEvents.inlinedAllStylesheets,
           'rrweb.version': RRWEB_VERSION,
+          'payload.type': recorderEvents.type,
           // customer-defined data should go last so that if it exceeds the query param padding limit it will be truncated instead of important attrs
           ...(endUserId && { 'enduser.id': endUserId })
           // The Query Param is being arbitrarily limited in length here.  It is also applied when estimating the size of the payload in getPayloadSize()

package/src/features/session_replay/constants.js

@@ -5,7 +5,8 @@ export const FEATURE_NAME = FEATURE_NAMES.sessionReplay
 
 export const SR_EVENT_EMITTER_TYPES = {
   RECORD: 'recordReplay',
-  PAUSE: 'pauseReplay'
+  PAUSE: 'pauseReplay',
+  REPLAY_RUNNING: 'replayRunning'
 }
 
 export const AVG_COMPRESSION = 0.12

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

@@ -24,6 +24,11 @@ export class Instrument extends InstrumentBase {
     } catch (err) { }
 
     if (this.#canPreloadRecorder(session)) {
+      /** If this is preloaded, set up a buffer, if not, later when sampling we will set up a .on for live events */
+      this.ee.on('err', (e) => {
+        this.errorNoticed = true
+        if (this.featAggregate) this.featAggregate.handleError()
+      })
       this.#startRecording(session?.sessionReplayMode)
     } else {
       this.importAggregator()
@@ -45,9 +50,9 @@ export class Instrument extends InstrumentBase {
 
   async #startRecording (mode) {
     const { Recorder } = (await import(/* webpackChunkName: "recorder" */'../shared/recorder'))
-    this.recorder = new Recorder({ mode, agentIdentifier: this.agentIdentifier })
+    this.recorder = new Recorder({ mode, agentIdentifier: this.agentIdentifier, ee: this.ee })
     this.recorder.startRecording()
     this.abortHandler = this.recorder.stopRecording
-    this.importAggregator({ recorder: this.recorder })
+    this.importAggregator({ recorder: this.recorder, errorNoticed: this.errorNoticed })
   }
 }

package/src/features/session_replay/shared/recorder-events.js

@@ -1,16 +1,11 @@
 export class RecorderEvents {
-  constructor ({ canCorrectTimestamps }) {
+  constructor () {
     /** The buffer to hold recorder event nodes */
     this.events = []
     /** Payload metadata -- Should indicate when a replay blob started recording.  Resets each time a harvest occurs.
      * cycle timestamps are used as fallbacks if event timestamps cannot be used
      */
     this.cycleTimestamp = Date.now()
-    /** Payload metadata -- Whether timestamps can be corrected, defaults as false, can be set to true if timekeeper is present at init time.  Used to determine
-     * if harvest needs to re-loop through nodes and correct them before sending.  Ideal behavior is to correct them as they flow into the recorder
-     * to prevent re-looping, but is not always possible since the timekeeper is not set until after page load and the recorder can be preloaded.
-    */
-    this.canCorrectTimestamps = !!canCorrectTimestamps
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     this.payloadBytesEstimation = 0
     /** Payload metadata -- Should indicate that the payload being sent has a full DOM snapshot. This can happen

package/src/features/session_replay/shared/recorder.js

@@ -1,6 +1,6 @@
 import { record as recorder } from 'rrweb'
 import { stringify } from '../../../common/util/stringify'
-import { AVG_COMPRESSION, CHECKOUT_MS, IDEAL_PAYLOAD_SIZE, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES } from '../constants'
+import { AVG_COMPRESSION, CHECKOUT_MS, IDEAL_PAYLOAD_SIZE, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES } from '../constants'
 import { getConfigurationValue } from '../../../common/config/config'
 import { RecorderEvents } from './recorder-events'
 import { MODE } from '../../../common/session/constants'
@@ -8,6 +8,7 @@ import { stylesheetEvaluator } from './stylesheet-evaluator'
 import { handle } from '../../../common/event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
+import { buildNRMetaNode } from './utils'
 
 export class Recorder {
   /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
@@ -20,9 +21,9 @@ export class Recorder {
   #fixing = false
 
   constructor (parent) {
-    this.#events = new RecorderEvents({ canCorrectTimestamps: !!parent.timeKeeper?.ready })
-    this.#backloggedEvents = new RecorderEvents({ canCorrectTimestamps: !!parent.timeKeeper?.ready })
-    this.#preloaded = [new RecorderEvents({ canCorrectTimestamps: !!parent.timeKeeper?.ready })]
+    this.#events = new RecorderEvents()
+    this.#backloggedEvents = new RecorderEvents()
+    this.#preloaded = [new RecorderEvents()]
     /** True when actively recording, false when paused or stopped */
     this.recording = false
     /** The pointer to the current bucket holding rrweb events */
@@ -40,14 +41,9 @@ export class Recorder {
   }
 
   getEvents () {
-    if (this.#preloaded[0]?.events.length) {
-      const preloadedEvents = this.returnCorrectTimestamps(this.#preloaded[0])
-      return { ...this.#preloaded[0], events: preloadedEvents, type: 'preloaded' }
-    }
-    const backloggedEvents = this.returnCorrectTimestamps(this.#backloggedEvents)
-    const events = this.returnCorrectTimestamps(this.#events)
+    if (this.#preloaded[0]?.events.length) return { ...this.#preloaded[0], type: 'preloaded' }
     return {
-      events: [...backloggedEvents, ...events].filter(x => x),
+      events: [...this.#backloggedEvents.events, ...this.#events.events].filter(x => x),
       type: 'standard',
       cycleTimestamp: Math.min(this.#backloggedEvents.cycleTimestamp, this.#events.cycleTimestamp),
       payloadBytesEstimation: this.#backloggedEvents.payloadBytesEstimation + this.#events.payloadBytesEstimation,
@@ -58,30 +54,22 @@ export class Recorder {
     }
   }
 
-  /**
-   * Returns time-corrected events. If the events were correctable from the beginning, this correction will have already been applied.
-   * @param {SessionReplayEvent[]} events The array of buffered SR nodes
-   * @returns {CorrectedSessionReplayEvent[]}
-   */
-  returnCorrectTimestamps (events) {
-    if (!this.parent.timeKeeper?.ready) return events.events
-    return events.canCorrectTimestamps
-      ? events.events
-      : events.events.map(({ __serialized, timestamp, ...e }) => ({ timestamp: this.parent.timeKeeper.correctAbsoluteTimestamp(timestamp), ...e }))
-  }
-
   /** Clears the buffer (this.#events), and resets all payload metadata properties */
   clearBuffer () {
     if (this.#preloaded[0]?.events.length) this.#preloaded.shift()
     else if (this.parent.mode === MODE.ERROR) this.#backloggedEvents = this.#events
-    else this.#backloggedEvents = new RecorderEvents({ canCorrectTimestamps: !!this.parent.timeKeeper?.ready })
-    this.#events = new RecorderEvents({ canCorrectTimestamps: !!this.parent.timeKeeper?.ready })
+    else this.#backloggedEvents = new RecorderEvents()
+    this.#events = new RecorderEvents()
   }
 
   /** Begin recording using configured recording lib */
   startRecording () {
     this.recording = true
     const { block_class, ignore_class, mask_text_class, block_selector, mask_input_options, mask_text_selector, mask_all_inputs, inline_stylesheet, inline_images, collect_fonts } = getConfigurationValue(this.parent.agentIdentifier, 'session_replay')
+    const customMasker = (text, element) => {
+      if (element?.type?.toLowerCase() !== 'password' && (element?.dataset.nrUnmask !== undefined || element?.classList.contains('nr-unmask'))) return text
+      return '*'.repeat(text.length)
+    }
     // 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({
@@ -92,15 +80,20 @@ export class Recorder {
       blockSelector: block_selector,
       maskInputOptions: mask_input_options,
       maskTextSelector: mask_text_selector,
+      maskTextFn: customMasker,
       maskAllInputs: mask_all_inputs,
+      maskInputFn: customMasker,
       inlineStylesheet: inline_stylesheet,
       inlineImages: inline_images,
       collectFonts: collect_fonts,
       checkoutEveryNms: CHECKOUT_MS[this.parent.mode]
     })
 
+    this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode])
+
     this.stopRecording = () => {
       this.recording = false
+      this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [false, this.parent.mode])
       stop()
     }
   }
@@ -148,7 +141,8 @@ export class Recorder {
 
     if (this.parent.blocked) return
 
-    if (this.currentBufferTarget.canCorrectTimestamps) {
+    if (this.parent.timeKeeper?.ready && !event.__newrelic) {
+      event.__newrelic = buildNRMetaNode(event.timestamp, this.parent.timeKeeper)
       event.timestamp = this.parent.timeKeeper.correctAbsoluteTimestamp(event.timestamp)
     }
     event.__serialized = stringify(event)
@@ -184,7 +178,7 @@ export class Recorder {
         this.parent.scheduler.runHarvest()
       } else {
         // we are still in "preload" and it triggered a "stop point".  Make a new set, which will get pointed at on next cycle
-        this.#preloaded.push(new RecorderEvents({ canCorrectTimestamps: !!this.parent.timeKeeper?.ready }))
+        this.#preloaded.push(new RecorderEvents())
       }
     }
   }

package/src/features/session_replay/shared/utils.js

@@ -17,3 +17,15 @@ export function canImportReplayAgg (agentId, sessionMgr) {
   if (!hasReplayPrerequisite(agentId)) return false
   return !!sessionMgr?.isNew || !!sessionMgr?.state.sessionReplayMode // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
 }
+
+export function buildNRMetaNode (timestamp, timeKeeper) {
+  const correctedTimestamp = timeKeeper.correctAbsoluteTimestamp(timestamp)
+  return {
+    originalTimestamp: timestamp,
+    correctedTimestamp,
+    timestampDiff: timestamp - correctedTimestamp,
+    timeKeeperOriginTime: timeKeeper.originTime,
+    timeKeeperCorrectedOriginTime: timeKeeper.correctedOriginTime,
+    timeKeeperDiff: Math.floor(timeKeeper.originTime - timeKeeper.correctedOriginTime)
+  }
+}

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

@@ -43,10 +43,11 @@ export class Aggregate extends AggregateBase {
     if (!this.agentRuntime.xhrWrappable) return
 
     this.resourceObserver = argsObj?.resourceObserver // undefined if observer couldn't be created
-    this.ptid = ''
+    this.ptid = this.agentRuntime.ptid
     this.trace = {}
     this.nodeCount = 0
     this.sentTrace = null
+    this.everSent = false
     this.harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10
     this.maxNodesPerHarvest = getConfigurationValue(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000
     /**
@@ -99,7 +100,7 @@ export class Aggregate extends AggregateBase {
 
         if (prevMode === MODE.ERROR && this.#scheduler) {
           this.trimSTNs(ERROR_MODE_SECONDS_WINDOW) // up until now, Trace would've been just buffering nodes up to max, which needs to be trimmed to last X seconds
-          this.#scheduler.runHarvest({ needResponse: true })
+          this.#scheduler.runHarvest({})
         } else {
           controlTraceOp(MODE.FULL)
         }
@@ -119,7 +120,7 @@ export class Aggregate extends AggregateBase {
       const stopTracePerm = () => {
         if (sessionEntity.state.sessionTraceMode !== MODE.OFF) sessionEntity.write({ sessionTraceMode: MODE.OFF })
         operationalGate.permanentlyDecide(false)
-        if (mostRecentModeKnown === MODE.FULL) this.#scheduler?.runHarvest() // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
+        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
       }
@@ -138,7 +139,7 @@ export class Aggregate extends AggregateBase {
           this.ee.on(SESSION_EVENTS.RESUME, () => {
             const updatedTraceMode = sessionEntity.state.sessionTraceMode
             if (updatedTraceMode === MODE.OFF) stopTracePerm()
-            else if (updatedTraceMode === MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({ needResponse: true })
+            else if (updatedTraceMode === MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({})
             mostRecentModeKnown = updatedTraceMode
           })
           this.ee.on(SESSION_EVENTS.PAUSE, () => { mostRecentModeKnown = sessionEntity.state.sessionTraceMode })
@@ -189,13 +190,12 @@ export class Aggregate extends AggregateBase {
       retryDelay: this.harvestTimeSeconds
     }, this)
     this.#scheduler.harvest.on('resources', this.#prepareHarvest.bind(this))
-    if (dontStartHarvestYet === false) this.#scheduler.runHarvest({ needResponse: true }) // sends first stn harvest immediately
+    if (dontStartHarvestYet === false) this.#scheduler.runHarvest({}) // sends first stn harvest immediately
     startupBuffer.decide(true) // signal to ALLOW & process data in EE's buffer into internal nodes queued for next harvest
   }
 
   #onHarvestFinished (result) {
-    if (result.sent && result.responseText && !this.ptid) { // continue interval harvest only if ptid was returned by server on the first
-      this.agentRuntime.ptid = this.ptid = result.responseText
+    if (result.sent && !result.failed && !this.#scheduler.started) { // continue interval harvest only after first call
       this.#scheduler.startTimer(this.harvestTimeSeconds)
     }
 
@@ -212,15 +212,18 @@ export class Aggregate extends AggregateBase {
 
   #prepareHarvest (options) {
     if (this.isStandalone) {
-      if (this.ptid && now() >= MAX_TRACE_DURATION) {
-        // Perform a final harvest once we hit or exceed the max session trace time
-        options.isFinalHarvest = true
-        this.operationalGate.permanentlyDecide(false)
-        this.#scheduler.stopTimer(true)
-      } else if (this.ptid && this.nodeCount <= REQ_THRESHOLD_TO_SEND && !options.isFinalHarvest) {
-        // Only harvest when more than some threshold of nodes are pending, after the very first harvest, with the exception of the last outgoing harvest.
-        return
+      if (this.#scheduler.started) {
+        if (now() >= MAX_TRACE_DURATION) {
+          // Perform a final harvest once we hit or exceed the max session trace time
+          options.isFinalHarvest = true
+          this.operationalGate.permanentlyDecide(false)
+          this.#scheduler.stopTimer(true)
+        } else if (this.nodeCount <= REQ_THRESHOLD_TO_SEND && !options.isFinalHarvest) {
+          // Only harvest when more than some threshold of nodes are pending, after the very first harvest, with the exception of the last outgoing harvest.
+          return
+        }
       }
+      // else, we must be on the very first harvest (standalone mode), so go to next square
     } else {
     //   -- *cli May '26 - Update: Not rate limiting backgrounded pages either for now.
     //   if (this.ptid && document.visibilityState === 'hidden' && this.nodeCount <= REQ_THRESHOLD_TO_SEND) return
@@ -231,7 +234,6 @@ export class Aggregate extends AggregateBase {
       if (currentMode === MODE.OFF && Object.keys(this.trace).length === 0) return
       if (currentMode === MODE.ERROR) return // Trace in this mode should never be harvesting, even on unload
     }
-
     return this.takeSTNs(options.retry)
   }
 

package/src/loaders/api/api.js

@@ -15,6 +15,7 @@ import { gosCDN } from '../../common/window/nreum'
 import { apiMethods, asyncApiMethods } from './api-methods'
 import { SR_EVENT_EMITTER_TYPES } from '../../features/session_replay/constants'
 import { now } from '../../common/timing/now'
+import { MODE } from '../../common/session/constants'
 
 export function setTopLevelCallers () {
   const nr = gosCDN()
@@ -33,12 +34,20 @@ export function setTopLevelCallers () {
   }
 }
 
+const replayRunning = {}
+
 export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false) {
   if (!forceDrain) registerDrain(agentIdentifier, 'api')
   const apiInterface = {}
   var instanceEE = ee.get(agentIdentifier)
   var tracerEE = instanceEE.get('tracer')
 
+  replayRunning[agentIdentifier] = MODE.OFF
+
+  instanceEE.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, (isRunning) => {
+    replayRunning[agentIdentifier] = isRunning
+  })
+
   var prefix = 'api-'
   var spaPrefix = prefix + 'ixn-'
 
@@ -184,7 +193,7 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
   apiInterface.noticeError = function (err, customAttributes) {
     if (typeof err === 'string') err = new Error(err)
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/noticeError/called'], undefined, FEATURE_NAMES.metrics, instanceEE)
-    handle('err', [err, now(), false, customAttributes], undefined, FEATURE_NAMES.jserrors, instanceEE)
+    handle('err', [err, now(), false, customAttributes, !!replayRunning[agentIdentifier]], undefined, FEATURE_NAMES.jserrors, instanceEE)
   }
 
   // theres no window.load event on non-browser scopes, lazy load immediately

package/src/loaders/configure/configure.js

@@ -52,6 +52,7 @@ export function configure (agent, opts = {}, loaderType, forceDrain) {
     ...(updatedInit.ajax.deny_list || []),
     ...(updatedInit.ajax.block_internal ? internalTrafficList : [])
   ]
+  runtime.ptid = agent.agentIdentifier
   setRuntime(agent.agentIdentifier, runtime)
 
   if (agent.api === undefined) agent.api = setAPI(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa)