@newrelic/browser-agent 1.256.1 → 1.258.0

package/dist/esm/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,225 +14,165 @@ 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();
-    });
-    const agentRuntime = getRuntime(agentIdentifier);
-    const denyList = agentRuntime.denyList;
-    setDenyList(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.#agentInfo = getInfo(agentIdentifier);
+    this.#agentRuntime = getRuntime(agentIdentifier);
+    this.#agentInit = getConfiguration(agentIdentifier);
+    const harvestTimeSeconds = this.#agentInit.ajax.harvestTimeSeconds || 10;
+    this.MAX_PAYLOAD_SIZE = this.#agentInit.ajax.maxPayloadSize || 1000000;
+    setDenyList(this.#agentRuntime.denyList);
+    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);
+    this.waitForFlags([]).then(() => {
+      const scheduler = new HarvestScheduler('events', {
+        onFinished: this.onEventsHarvestFinished.bind(this),
+        getPayload: this.prepareHarvest.bind(this)
+      }, this);
+      scheduler.startTimer(harvestTimeSeconds);
+      this.drain();
+    });
+  }
+  storeXhr(params, metrics, startTime, endTime, type, ctx) {
+    metrics.time = startTime;
 
-    const beacon = getInfo(agentIdentifier).errorBeacon;
-    const proxyBeacon = agentInit.proxy.beacon;
-    function storeXhr(params, metrics, startTime, endTime, type) {
-      metrics.time = startTime;
+    // send to session traces
+    let hash;
+    if (params.cat) {
+      hash = stringify([params.status, params.cat]);
+    } else {
+      hash = stringify([params.status, params.host, params.pathname]);
+    }
+    const shouldCollect = shouldCollectEvent(params);
+    const shouldOmitAjaxMetrics = this.#agentInit.feature_flags?.includes('ajax_metrics_deny_list');
 
-      // send to session traces
-      var hash;
-      if (params.cat) {
-        hash = stringify([params.status, params.cat]);
+    // store for timeslice metric (harvested by jserrors feature)
+    if (shouldCollect || !shouldOmitAjaxMetrics) {
+      this.aggregator.store('xhr', hash, params, metrics);
+    }
+    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);
+        if (shouldOmitAjaxMetrics) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, this.ee);
       } else {
-        hash = stringify([params.status, params.host, params.pathname]);
+        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, this.ee);
+        if (shouldOmitAjaxMetrics) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, FEATURE_NAMES.metrics, this.ee);
       }
-      const shouldCollect = shouldCollectEvent(params);
-      const ajaxMetricDenyListEnabled = agentInit.feature_flags?.includes('ajax_metrics_deny_list');
+      return; // do not send this ajax as an event
+    }
+    handle('bstXhrAgg', ['xhr', hash, params, metrics], undefined, FEATURE_NAMES.sessionTrace, this.ee); // have trace feature harvest AjaxNode
 
-      // store as metric
-      if (shouldCollect || !ajaxMetricDenyListEnabled) {
-        aggregator.store('xhr', hash, params, metrics);
-      }
-      if (!shouldCollect) {
-        if (params.hostname === beacon || proxyBeacon && params.hostname === proxyBeacon) {
-          // This doesn't make a distinction if the same-domain request is going to a different port or path...
-          handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee);
-          if (ajaxMetricDenyListEnabled) {
-            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee);
-          }
-        } else {
-          handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee);
-          if (ajaxMetricDenyListEnabled) {
-            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee);
-          }
-        }
-        return;
-      }
-      handle('bstXhrAgg', ['xhr', hash, params, metrics], undefined, FEATURE_NAMES.sessionTrace, ee);
-      var xhrContext = this;
-      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 (xhrContext.dt) {
-        event.spanId = xhrContext.dt.spanId;
-        event.traceId = xhrContext.dt.traceId;
-        event.spanTimestamp = agentRuntime.timeKeeper.correctAbsoluteTimestamp(xhrContext.dt.timestamp);
-      }
+    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
+    };
+    if (ctx.dt) {
+      event.spanId = ctx.dt.spanId;
+      event.traceId = ctx.dt.traceId;
+      event.spanTimestamp = this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(ctx.dt.timestamp);
+    }
 
-      // 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);
-      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);
-      }
+    // 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);
     }
-    function prepareHarvest(options) {
-      options = options || {};
-      if (ajaxEvents.length === 0) {
-        return null;
-      }
-      var payload = getPayload(ajaxEvents, options.maxPayloadSize || MAX_PAYLOAD_SIZE);
-      var payloadObjs = [];
-      for (var i = 0; i < payload.length; i++) {
-        payloadObjs.push({
-          body: {
-            e: payload[i]
-          }
-        });
-      }
-      if (options.retry) {
-        sentAjaxEvents = ajaxEvents.slice();
+  }
+  prepareHarvest(options) {
+    options = options || {};
+    if (this.ajaxEvents.length === 0) return null;
+    const payload = this.#getPayload(this.ajaxEvents);
+    const payloadObjs = [];
+    for (let i = 0; i < payload.length; i++) payloadObjs.push({
+      body: {
+        e: payload[i]
       }
-      ajaxEvents = [];
-      return payloadObjs;
+    });
+    if (options.retry) this.sentAjaxEvents = this.ajaxEvents;
+    this.ajaxEvents = [];
+    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/dist/esm/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';
@@ -26,9 +26,6 @@ export class Instrument extends InstrumentBase {
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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/dist/esm/features/jserrors/aggregate/index.js

@@ -37,13 +37,9 @@ 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', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
@@ -89,11 +85,7 @@ export class Aggregate extends AggregateBase {
       payload.qs.ri = releaseIds;
     }
     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;
@@ -167,14 +159,14 @@ export class Aggregate extends AggregateBase {
     // Notice if filterOutput isn't false|undefined OR our specified object, this func would've returned already (so it's unnecessary to req-check group).
     // 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("".concat(stackInfo.name, "_").concat(stackInfo.message, "_").concat(stackInfo.stackString));
+    var bucketHash = stringHashCode("".concat(stackInfo.name, "_").concat(stackInfo.message, "_").concat(stackInfo.stackString, "_").concat(params.hasReplay ? 1 : 0));
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true;
       params.stack_trace = truncateSize(stackInfo.stackString);
@@ -193,9 +185,8 @@ export class Aggregate extends AggregateBase {
       params.pageview = 1;
       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
@@ -288,4 +279,26 @@ 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.".concat(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/dist/esm/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';
@@ -95,14 +95,14 @@ export class Aggregate extends AggregateBase {
         // 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);
@@ -134,7 +134,7 @@ export class Aggregate extends AggregateBase {
           return;
         }
         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');
           agentRuntime.timeKeeper = timeKeeper;

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

@@ -52,9 +52,11 @@ export class Aggregate extends AggregateBase {
     /** set at BCS response, stored in runtime */
     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.".concat(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, () => {
@@ -101,6 +103,9 @@ export class Aggregate extends AggregateBase {
     registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
       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,
@@ -149,15 +154,17 @@ 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);
     }
   }
 
@@ -218,7 +225,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.
@@ -312,7 +318,7 @@ export class Aggregate extends AggregateBase {
     return [payload];
   }
   getCorrectedTimestamp(node) {
-    if (!node.timestamp) return;
+    if (!node?.timestamp) return;
     if (node.__newrelic) return node.timestamp;
     return this.timeKeeper.correctAbsoluteTimestamp(node.timestamp);
   }
@@ -362,6 +368,7 @@ export class Aggregate extends AggregateBase {
           ...(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/dist/esm/features/session_replay/constants.js

@@ -4,7 +4,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;
 export const RRWEB_EVENT_TYPES = {

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

@@ -9,9 +9,10 @@
  * It is not production ready, and is not intended to be imported or implemented in any build of the browser agent until
  * functionality is validated and a full user experience is curated.
  */
+import { handle } from '../../../common/event-emitter/handle';
 import { DEFAULT_KEY, MODE, PREFIX } from '../../../common/session/constants';
 import { InstrumentBase } from '../../utils/instrument-base';
-import { FEATURE_NAME } from '../constants';
+import { FEATURE_NAME, SR_EVENT_EMITTER_TYPES } from '../constants';
 import { isPreloadAllowed } from '../shared/utils';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
@@ -19,19 +20,28 @@ export class Instrument extends InstrumentBase {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
     let session;
+    this.replayRunning = false;
     try {
       session = JSON.parse(localStorage.getItem("".concat(PREFIX, "_").concat(DEFAULT_KEY)));
     } 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();
     }
+
+    /** If the recorder is running, we can pass error events on to the agg to help it switch to full mode later */
+    this.ee.on('err', e => {
+      if (this.replayRunning) {
+        this.errorNoticed = true;
+        handle(SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, [e], undefined, this.featureName, this.ee);
+      }
+    });
+
+    /** Emitted by the recorder when it starts capturing data, used to determine if we should pass errors on to the agg */
+    this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
+      this.replayRunning = isRunning;
+    });
   }
 
   // At this point wherein session state exists already but we haven't init SessionEntity aka verify timers.