@newrelic/browser-agent 1.256.1 → 1.258.0

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

@@ -4,7 +4,6 @@
  */
 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'
 import { getConfiguration, getInfo, getRuntime } from '../../../common/config/config'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
@@ -15,251 +14,180 @@ import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { parseGQL } from './gql'
 import { getNREUMInitializedAgent } from '../../../common/window/nreum'
+import Chunk from './chunk'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
+  #agentInfo
+  #agentRuntime
+  #agentInit
+
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
-    const agentInit = getConfiguration(agentIdentifier)
-
-    registerHandler('xhr', storeXhr, this.featureName, this.ee)
 
-    this.waitForFlags(([])).then(() => {
-      const scheduler = new HarvestScheduler('events', {
-        onFinished: onEventsHarvestFinished,
-        getPayload: prepareHarvest
-      }, this)
-      scheduler.startTimer(harvestTimeSeconds)
-      this.drain()
-    })
+    this.#agentInfo = getInfo(agentIdentifier)
+    this.#agentRuntime = getRuntime(agentIdentifier)
+    this.#agentInit = getConfiguration(agentIdentifier)
 
-    const agentRuntime = getRuntime(agentIdentifier)
-    const denyList = agentRuntime.denyList
-    setDenyList(denyList)
+    const harvestTimeSeconds = this.#agentInit.ajax.harvestTimeSeconds || 10
+    this.MAX_PAYLOAD_SIZE = this.#agentInit.ajax.maxPayloadSize || 1000000
+    setDenyList(this.#agentRuntime.denyList)
 
-    let ajaxEvents = []
-    let spaAjaxEvents = {}
-    let sentAjaxEvents = []
-    const ee = this.ee
-
-    const harvestTimeSeconds = agentInit.ajax.harvestTimeSeconds || 10
-    const MAX_PAYLOAD_SIZE = agentInit.ajax.maxPayloadSize || 1000000
-
-    // Exposes these methods to browser test files -- future TO DO: can be removed once these fns are extracted from the constructor into class func
-    this.storeXhr = storeXhr
-    this.prepareHarvest = prepareHarvest
-    this.getStoredEvents = function () { return { ajaxEvents, spaAjaxEvents } }
+    this.ajaxEvents = []
+    this.spaAjaxEvents = {}
+    this.sentAjaxEvents = []
+    const classThis = this
 
     // --- v Used by old spa feature
-    ee.on('interactionDone', (interaction, wasSaved) => {
-      if (!spaAjaxEvents[interaction.id]) return
+    this.ee.on('interactionDone', (interaction, wasSaved) => {
+      if (!this.spaAjaxEvents[interaction.id]) return
 
       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)
-        })
+        this.spaAjaxEvents[interaction.id].forEach((item) => this.ajaxEvents.push(item))
       }
-      delete spaAjaxEvents[interaction.id]
+      delete this.spaAjaxEvents[interaction.id]
     })
     // --- ^
     // --- v Used by new soft nav
-    registerHandler('returnAjax', event => ajaxEvents.push(event), this.featureName, this.ee)
+    registerHandler('returnAjax', event => this.ajaxEvents.push(event), this.featureName, this.ee)
     // --- ^
+    registerHandler('xhr', function () { // the EE-drain system not only switches "this" but also passes a new EventContext with info. Should consider platform refactor to another system which passes a mutable context around separately and predictably to avoid problems like this.
+      classThis.storeXhr(...arguments, this) // this switches the context back to the class instance while passing the NR context as an argument -- see "ctx" in storeXhr
+    }, this.featureName, this.ee)
 
-    const beacon = getInfo(agentIdentifier).errorBeacon
-    const proxyBeacon = agentInit.proxy.beacon
-
-    function storeXhr (params, metrics, startTime, endTime, type) {
-      metrics.time = startTime
-
-      // send to session traces
-      var hash
-      if (params.cat) {
-        hash = stringify([params.status, params.cat])
-      } 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
-      if (shouldCollect || !ajaxMetricDenyListEnabled) {
-        aggregator.store('xhr', hash, params, metrics)
-      }
+    this.waitForFlags(([])).then(() => {
+      const scheduler = new HarvestScheduler('events', {
+        onFinished: this.onEventsHarvestFinished.bind(this),
+        getPayload: this.prepareHarvest.bind(this)
+      }, this)
+      scheduler.startTimer(harvestTimeSeconds)
+      this.drain()
+    })
+  }
 
-      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)
+  storeXhr (params, metrics, startTime, endTime, type, ctx) {
+    metrics.time = startTime
 
-          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)
+    // send to session traces
+    let hash
+    if (params.cat) {
+      hash = stringify([params.status, params.cat])
+    } else {
+      hash = stringify([params.status, params.host, params.pathname])
+    }
 
-          if (ajaxMetricDenyListEnabled) {
-            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee)
-          }
-        }
-        return
-      }
+    const shouldCollect = shouldCollectEvent(params)
+    const shouldOmitAjaxMetrics = this.#agentInit.feature_flags?.includes('ajax_metrics_deny_list')
 
-      handle('bstXhrAgg', ['xhr', hash, params, metrics], undefined, FEATURE_NAMES.sessionTrace, ee)
+    // store for timeslice metric (harvested by jserrors feature)
+    if (shouldCollect || !shouldOmitAjaxMetrics) {
+      this.aggregator.store('xhr', hash, params, metrics)
+    }
 
-      var xhrContext = this
+    if (!shouldCollect) {
+      if (params.hostname === this.#agentInfo.errorBeacon || (this.#agentInit.proxy?.beacon && params.hostname === this.#agentInit.proxy.beacon)) {
+        // 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, this.ee)
 
-      var event = {
-        method: params.method,
-        status: params.status,
-        domain: params.host,
-        path: params.pathname,
-        requestSize: metrics.txSize,
-        responseSize: metrics.rxSize,
-        type,
-        startTime,
-        endTime,
-        callbackDuration: metrics.cbTime
-      }
+        if (shouldOmitAjaxMetrics) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, this.ee)
+      } else {
+        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, this.ee)
 
-      if (xhrContext.dt) {
-        event.spanId = xhrContext.dt.spanId
-        event.traceId = xhrContext.dt.traceId
-        event.spanTimestamp = agentRuntime.timeKeeper.correctAbsoluteTimestamp(xhrContext.dt.timestamp)
+        if (shouldOmitAjaxMetrics) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, FEATURE_NAMES.metrics, this.ee)
       }
+      return // do not send this ajax as an event
+    }
 
-      // parsed from the AJAX body, looking for operationName param & parsing query for operationType
-      event.gql = params.gql = parseGQL({
-        body: this.body,
-        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)
+    handle('bstXhrAgg', ['xhr', hash, params, metrics], undefined, FEATURE_NAMES.sessionTrace, this.ee) // have trace feature harvest AjaxNode
+
+    const event = {
+      method: params.method,
+      status: params.status,
+      domain: params.host,
+      path: params.pathname,
+      requestSize: metrics.txSize,
+      responseSize: metrics.rxSize,
+      type,
+      startTime,
+      endTime,
+      callbackDuration: metrics.cbTime
+    }
 
-      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 {
-        ajaxEvents.push(event)
-      }
+    if (ctx.dt) {
+      event.spanId = ctx.dt.spanId
+      event.traceId = ctx.dt.traceId
+      event.spanTimestamp = this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(ctx.dt.timestamp)
     }
 
-    function prepareHarvest (options) {
-      options = options || {}
+    // parsed from the AJAX body, looking for operationName param & parsing query for operationType
+    event.gql = params.gql = parseGQL({
+      body: ctx.body,
+      query: ctx.parsedOrigin?.search
+    })
+    if (event.gql) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length], undefined, FEATURE_NAMES.metrics, this.ee)
+
+    const softNavInUse = Boolean(getNREUMInitializedAgent(this.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, this.ee)
+    } else if (ctx.spaNode) { // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
+      const interactionId = ctx.spaNode.interaction.id
+      this.spaAjaxEvents[interactionId] = this.spaAjaxEvents[interactionId] || []
+      this.spaAjaxEvents[interactionId].push(event)
+    } else {
+      this.ajaxEvents.push(event)
+    }
+  }
 
-      if (ajaxEvents.length === 0) {
-        return null
-      }
+  prepareHarvest (options) {
+    options = options || {}
+    if (this.ajaxEvents.length === 0) return null
 
-      var payload = getPayload(ajaxEvents, options.maxPayloadSize || MAX_PAYLOAD_SIZE)
+    const payload = this.#getPayload(this.ajaxEvents)
+    const payloadObjs = []
 
-      var payloadObjs = []
-      for (var i = 0; i < payload.length; i++) {
-        payloadObjs.push({ body: { e: payload[i] } })
-      }
+    for (let i = 0; i < payload.length; i++) payloadObjs.push({ body: { e: payload[i] } })
 
-      if (options.retry) {
-        sentAjaxEvents = ajaxEvents.slice()
-      }
+    if (options.retry) this.sentAjaxEvents = this.ajaxEvents
+    this.ajaxEvents = []
 
-      ajaxEvents = []
+    return payloadObjs
+  }
 
-      return payloadObjs
+  onEventsHarvestFinished (result) {
+    if (result.retry && this.sentAjaxEvents.length > 0) {
+      this.ajaxEvents.unshift(...this.sentAjaxEvents)
+      this.sentAjaxEvents = []
     }
+  }
 
-    function getPayload (events, maxPayloadSize, chunks) {
-      chunks = chunks || 1
-      var payload = []
-      var chunkSize = events.length / chunks
-      var eventChunks = splitChunks(events, chunkSize)
-      var tooBig = false
-      for (var i = 0; i < eventChunks.length; i++) {
-        var currentChunk = eventChunks[i]
-        if (currentChunk.tooBig(maxPayloadSize)) {
-          if (currentChunk.events.length !== 1) {
-            /* if it is too big BUT it isnt length 1, we can split it down again,
-             else we just want to NOT push it into payload
-             because if it's length 1 and still too big for the maxPayloadSize
-             it cant get any smaller and we dont want to recurse forever */
-            tooBig = true
-            break
-          }
-        } else {
-          payload.push(currentChunk.payload)
+  #getPayload (events, numberOfChunks) {
+    numberOfChunks = numberOfChunks || 1
+    const payload = []
+    const chunkSize = events.length / numberOfChunks
+    const eventChunks = splitChunks.call(this, events, chunkSize)
+    let tooBig = false
+    for (let i = 0; i < eventChunks.length; i++) {
+      const currentChunk = eventChunks[i]
+      if (currentChunk.tooBig) {
+        if (currentChunk.events.length > 1) {
+          tooBig = true
+          break // if the payload is too big BUT is made of more than 1 event, we can split it down again
         }
-      }
-      // check if the current payload string is too big, if so then run getPayload again with more buckets
-      return tooBig ? getPayload(events, maxPayloadSize, ++chunks) : payload
-    }
-
-    function onEventsHarvestFinished (result) {
-      if (result.retry && sentAjaxEvents.length > 0) {
-        ajaxEvents.unshift(...sentAjaxEvents)
-        sentAjaxEvents = []
+        // Otherwise, if it consists of one sole event, we do not send it (discarded) since we cannot break it apart any further.
+      } else {
+        payload.push(currentChunk.payload)
       }
     }
+    // Check if the current payload string is too big, if so then run getPayload again with more buckets.
+    return tooBig ? this.#getPayload(events, ++numberOfChunks) : payload
 
     function splitChunks (arr, chunkSize) {
       chunkSize = chunkSize || arr.length
-      var chunks = []
-      for (var i = 0, len = arr.length; i < len; i += chunkSize) {
-        chunks.push(new Chunk(arr.slice(i, i + chunkSize)))
+      const chunks = []
+      for (let i = 0, len = arr.length; i < len; i += chunkSize) {
+        chunks.push(new Chunk(arr.slice(i, i + chunkSize), this))
       }
       return chunks
     }
-
-    function Chunk (events) {
-      this.addString = getAddStringContext(agentIdentifier) // pass agentIdentifier here
-      this.events = events
-      this.payload = 'bel.7;'
-
-      for (var i = 0; i < events.length; i++) {
-        var event = events[i]
-
-        var fields = [
-          numeric(event.startTime),
-          numeric(event.endTime - event.startTime),
-          numeric(0), // callbackEnd
-          numeric(0), // no callbackDuration for non-SPA events
-          this.addString(event.method),
-          numeric(event.status),
-          this.addString(event.domain),
-          this.addString(event.path),
-          numeric(event.requestSize),
-          numeric(event.responseSize),
-          event.type === 'fetch' ? 1 : '',
-          this.addString(0), // nodeId
-          nullable(event.spanId, this.addString, true) + // guid
-          nullable(event.traceId, this.addString, true) + // traceId
-          nullable(event.spanTimestamp, numeric, false) // timestamp
-        ]
-
-        var insert = '2,'
-
-        // add custom attributes
-        // gql decorators are added as custom attributes to alleviate need for new BEL schema
-        var attrParts = addCustomAttributes({ ...(getInfo(agentIdentifier).jsAttributes || {}), ...(event.gql || {}) }, this.addString)
-        fields.unshift(numeric(attrParts.length))
-
-        insert += fields.join(',')
-
-        if (attrParts && attrParts.length > 0) {
-          insert += ';' + attrParts.join(';')
-        }
-
-        if ((i + 1) < events.length) insert += ';'
-
-        this.payload += insert
-      }
-
-      this.tooBig = function (maxPayloadSize) {
-        maxPayloadSize = maxPayloadSize || MAX_PAYLOAD_SIZE
-        return this.payload.length * 2 > maxPayloadSize
-      }
-    }
   }
 }

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

@@ -2,7 +2,7 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { originals, getLoaderConfig, getRuntime } from '../../../common/config/config'
+import { originals, getLoaderConfig } from '../../../common/config/config'
 import { handle } from '../../../common/event-emitter/handle'
 import { id } from '../../../common/ids/id'
 import { ffVersion, globalScope, isBrowserScope } from '../../../common/constants/runtime'
@@ -29,9 +29,6 @@ export class Instrument extends InstrumentBase {
   constructor (agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto)
 
-    // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
-    if (!getRuntime(agentIdentifier).xhrWrappable) return
-
     this.dt = new DT(agentIdentifier)
 
     this.handler = (type, args, ctx, group) => handle(type, args, ctx, group, this.ee)

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

@@ -38,13 +38,10 @@ 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) =>
@@ -82,16 +79,13 @@ export class Aggregate extends AggregateBase {
     }
 
     if (body && body.err && body.err.length) {
-      if (this.replayAborted) {
-        body.err.forEach((e) => {
-          delete e.params?.hasReplay
-        })
-      }
+      this.#runCrossFeatureChecks(body.err)
       if (!this.errorOnPage) {
         payload.qs.pve = '1'
         this.errorOnPage = true
       }
     }
+
     return payload
   }
 
@@ -172,13 +166,14 @@ export class Aggregate extends AggregateBase {
     // Do not modify the name ('errorGroup') of params without DEM approval!
     if (filterOutput?.group) params.errorGroup = filterOutput.group
 
+    if (hasReplay) params.hasReplay = hasReplay
     /**
      * The bucketHash is different from the params.stackHash because the params.stackHash is based on the canonicalized
      * stack trace and is used downstream in NR1 to attempt to group the same errors across different browsers. However,
      * the canonical stack trace excludes items like the column number increasing the hit-rate of different errors potentially
      * bucketing and ultimately resulting in the loss of data in NR1.
      */
-    var bucketHash = stringHashCode(`${stackInfo.name}_${stackInfo.message}_${stackInfo.stackString}`)
+    var bucketHash = stringHashCode(`${stackInfo.name}_${stackInfo.message}_${stackInfo.stackString}_${params.hasReplay ? 1 : 0}`)
 
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true
@@ -199,9 +194,8 @@ export class Aggregate extends AggregateBase {
       this.pageviewReported[bucketHash] = true
     }
 
-    if (hasReplay && !this.replayAborted) params.hasReplay = hasReplay
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash]
-    params.timestamp = this.observedAt[bucketHash]
+    params.timestamp = agentRuntime.timeKeeper.convertRelativeTimestamp(time)
 
     var type = internal ? 'ierr' : 'err'
     var newMetrics = { time }
@@ -296,4 +290,27 @@ export class Aggregate extends AggregateBase {
     )
     delete this.bufferedErrorsUnderSpa[interactionId] // wipe the list of jserrors so they aren't duplicated by another call to the same id
   }
+
+  /**
+   * Dispatches a cross-feature communication event to allow other
+   * features to provide flags and data that can be used to mutation
+   * to the payload and to allow features to know about a feature
+   * harvest happening.
+   * @param {any[]} errors Array of errors from the payload body
+   */
+  #runCrossFeatureChecks (errors) {
+    const errorHashes = errors.map(error => error.params.stackHash)
+    const crossFeatureData = {
+      errorHashes
+    }
+    this.ee.emit(`cfc.${this.featureName}`, [crossFeatureData])
+
+    let hasReplayFlag = errors.find(err => err.params.hasReplay)
+    if (hasReplayFlag && !crossFeatureData.hasReplay) {
+      // Some errors have `hasReplay` and a replay is not being recorded
+      errors.forEach(error => {
+        delete error.params.hasReplay
+      })
+    }
+  }
 }

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

@@ -1,4 +1,4 @@
-import { globalScope, isBrowserScope } from '../../../common/constants/runtime'
+import { globalScope, isBrowserScope, originTime } from '../../../common/constants/runtime'
 import { addPT, addPN } from '../../../common/timing/nav-timing'
 import { stringify } from '../../../common/util/stringify'
 import { getInfo, getRuntime } from '../../../common/config/config'
@@ -86,13 +86,13 @@ export class Aggregate extends AggregateBase {
       if (typeof PerformanceNavigationTiming !== 'undefined') { // Navigation Timing level 2 API that replaced PerformanceTiming & PerformanceNavigation
         const navTimingEntry = globalScope?.performance?.getEntriesByType('navigation')?.[0]
         const perf = ({
-          timing: addPT(agentRuntime.offset, navTimingEntry, {}),
+          timing: addPT(originTime, navTimingEntry, {}),
           navigation: addPN(navTimingEntry, {})
         })
         queryParameters.perf = stringify(perf)
       } else if (typeof PerformanceTiming !== 'undefined') { // Safari pre-15 did not support level 2 timing
         const perf = ({
-          timing: addPT(agentRuntime.offset, globalScope.performance.timing, {}, true),
+          timing: addPT(originTime, globalScope.performance.timing, {}, true),
           navigation: addPN(globalScope.performance.navigation, {})
         })
         queryParameters.perf = stringify(perf)
@@ -117,7 +117,7 @@ export class Aggregate extends AggregateBase {
         }
 
         try {
-          const timeKeeper = new TimeKeeper()
+          const timeKeeper = new TimeKeeper(this.agentIdentifier)
           timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime)
           if (!timeKeeper.ready) throw new Error('TimeKeeper not ready')
 

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

@@ -54,11 +54,18 @@ export class Aggregate extends AggregateBase {
     this.timeKeeper = undefined
 
     this.recorder = args?.recorder
-    this.preloaded = !!this.recorder
     this.errorNoticed = args?.errorNoticed || false
 
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, this.ee)
 
+    this.ee.on(`cfc.${FEATURE_NAMES.jserrors}`, (crossFeatureData) => {
+      crossFeatureData.hasReplay = !!(this.scheduler?.started &&
+        this.recorder &&
+        this.mode === MODE.FULL &&
+        !this.blocked &&
+        this.entitled)
+    })
+
     // 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.abort(ABORT_REASONS.RESET)
@@ -104,6 +111,10 @@ export class Aggregate extends AggregateBase {
       this.forceStop(this.mode !== MODE.ERROR)
     }, this.featureName, this.ee)
 
+    registerHandler(SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, e => {
+      this.handleError(e)
+    }, 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]) => {
@@ -148,15 +159,15 @@ export class Aggregate extends AggregateBase {
   }
 
   switchToFull () {
+    if (!this.entitled || this.blocked) return
     this.mode = MODE.FULL
     // if the error was noticed AFTER the recorder was already imported....
     if (this.recorder && this.initialized) {
-      this.recorder.stopRecording()
-      this.recorder.startRecording()
-
+      if (!this.recorder.recording) this.recorder.startRecording()
       this.scheduler.startTimer(this.harvestTimeSeconds)
-
       this.syncWithSessionManager({ sessionReplayMode: this.mode })
+    } else {
+      this.initializeRecording(false, true, true)
     }
   }
 
@@ -213,7 +224,6 @@ export class Aggregate extends AggregateBase {
 
     // 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.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.
@@ -293,7 +303,7 @@ export class Aggregate extends AggregateBase {
   }
 
   getCorrectedTimestamp (node) {
-    if (!node.timestamp) return
+    if (!node?.timestamp) return
     if (node.__newrelic) return node.timestamp
     return this.timeKeeper.correctAbsoluteTimestamp(node.timestamp)
   }
@@ -331,6 +341,7 @@ export class Aggregate extends AggregateBase {
     const lastTimestamp = lastEventTimestamp || this.timeKeeper.convertRelativeTimestamp(relativeNow)
 
     const agentMetadata = agentRuntime.appMetadata?.agents?.[0] || {}
+
     return {
       qs: {
         browser_monitoring_key: info.licenseKey,
@@ -343,6 +354,7 @@ export class Aggregate extends AggregateBase {
           // if not, data could be lost to truncation at time of sending, potentially breaking parsing / API behavior in NR1
           ...(!!this.gzipper && !!this.u8 && { content_encoding: 'gzip' }),
           ...(agentMetadata.entityGuid && { entityGuid: agentMetadata.entityGuid }),
+          harvestId: [agentRuntime.session?.state.value, agentRuntime.ptid, agentRuntime.harvestCount].filter(x => x).join('_'),
           'replay.firstTimestamp': firstTimestamp,
           'replay.lastTimestamp': lastTimestamp,
           'replay.nodes': events.length,

package/src/features/session_replay/constants.js

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