@newrelic/browser-agent 1.256.1 → 1.258.0

package/dist/cjs/features/ajax/aggregate/index.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.Aggregate = void 0;
 var _registerHandler = require("../../../common/event-emitter/register-handler");
 var _stringify = require("../../../common/util/stringify");
-var _belSerializer = require("../../../common/serialize/bel-serializer");
 var _handle = require("../../../common/event-emitter/handle");
 var _config = require("../../../common/config/config");
 var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
@@ -17,6 +16,8 @@ var _constants2 = require("../../metrics/constants");
 var _aggregateBase = require("../../utils/aggregate-base");
 var _gql = require("./gql");
 var _nreum = require("../../../common/window/nreum");
+var _chunk = _interopRequireDefault(require("./chunk"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -24,224 +25,163 @@ var _nreum = require("../../../common/window/nreum");
 
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
+  #agentInfo;
+  #agentRuntime;
+  #agentInit;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
-    const agentInit = (0, _config.getConfiguration)(agentIdentifier);
-    (0, _registerHandler.registerHandler)('xhr', storeXhr, this.featureName, this.ee);
-    this.waitForFlags([]).then(() => {
-      const scheduler = new _harvestScheduler.HarvestScheduler('events', {
-        onFinished: onEventsHarvestFinished,
-        getPayload: prepareHarvest
-      }, this);
-      scheduler.startTimer(harvestTimeSeconds);
-      this.drain();
-    });
-    const agentRuntime = (0, _config.getRuntime)(agentIdentifier);
-    const denyList = agentRuntime.denyList;
-    (0, _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 = (0, _config.getInfo)(agentIdentifier);
+    this.#agentRuntime = (0, _config.getRuntime)(agentIdentifier);
+    this.#agentInit = (0, _config.getConfiguration)(agentIdentifier);
+    const harvestTimeSeconds = this.#agentInit.ajax.harvestTimeSeconds || 10;
+    this.MAX_PAYLOAD_SIZE = this.#agentInit.ajax.maxPayloadSize || 1000000;
+    (0, _denyList.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
-    (0, _registerHandler.registerHandler)('returnAjax', event => ajaxEvents.push(event), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('returnAjax', event => this.ajaxEvents.push(event), this.featureName, this.ee);
     // --- ^
+    (0, _registerHandler.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.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 = (0, _config.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 = (0, _stringify.stringify)([params.status, params.cat]);
+    } else {
+      hash = (0, _stringify.stringify)([params.status, params.host, params.pathname]);
+    }
+    const shouldCollect = (0, _denyList.shouldCollectEvent)(params);
+    const shouldOmitAjaxMetrics = this.#agentInit.feature_flags?.includes('ajax_metrics_deny_list');
 
-      // send to session traces
-      var hash;
-      if (params.cat) {
-        hash = (0, _stringify.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...
+        (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+        if (shouldOmitAjaxMetrics) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
       } else {
-        hash = (0, _stringify.stringify)([params.status, params.host, params.pathname]);
+        (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+        if (shouldOmitAjaxMetrics) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
       }
-      const shouldCollect = (0, _denyList.shouldCollectEvent)(params);
-      const ajaxMetricDenyListEnabled = agentInit.feature_flags?.includes('ajax_metrics_deny_list');
+      return; // do not send this ajax as an event
+    }
+    (0, _handle.handle)('bstXhrAgg', ['xhr', hash, params, metrics], undefined, _features.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...
-          (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, _features.FEATURE_NAMES.metrics, ee);
-          if (ajaxMetricDenyListEnabled) {
-            (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, _features.FEATURE_NAMES.metrics, ee);
-          }
-        } else {
-          (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, _features.FEATURE_NAMES.metrics, ee);
-          if (ajaxMetricDenyListEnabled) {
-            (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, _features.FEATURE_NAMES.metrics, ee);
-          }
-        }
-        return;
-      }
-      (0, _handle.handle)('bstXhrAgg', ['xhr', hash, params, metrics], undefined, _features.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 = (0, _gql.parseGQL)({
-        body: this.body,
-        query: this?.parsedOrigin?.search
-      });
-      if (event.gql) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', (0, _stringify.stringify)(event.gql).length], undefined, _features.FEATURE_NAMES.metrics, ee);
-      const softNavInUse = Boolean((0, _nreum.getNREUMInitializedAgent)(agentIdentifier)?.features?.[_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
-        (0, _handle.handle)('ajax', [event], undefined, _features.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 = (0, _gql.parseGQL)({
+      body: ctx.body,
+      query: ctx.parsedOrigin?.search
+    });
+    if (event.gql) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', (0, _stringify.stringify)(event.gql).length], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    const softNavInUse = Boolean((0, _nreum.getNREUMInitializedAgent)(this.agentIdentifier)?.features?.[_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
+      (0, _handle.handle)('ajax', [event], undefined, _features.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.default(arr.slice(i, i + chunkSize), this));
       }
       return chunks;
     }
-    function Chunk(events) {
-      this.addString = (0, _belSerializer.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 = [(0, _belSerializer.numeric)(event.startTime), (0, _belSerializer.numeric)(event.endTime - event.startTime), (0, _belSerializer.numeric)(0),
-        // callbackEnd
-        (0, _belSerializer.numeric)(0),
-        // no callbackDuration for non-SPA events
-        this.addString(event.method), (0, _belSerializer.numeric)(event.status), this.addString(event.domain), this.addString(event.path), (0, _belSerializer.numeric)(event.requestSize), (0, _belSerializer.numeric)(event.responseSize), event.type === 'fetch' ? 1 : '', this.addString(0),
-        // nodeId
-        (0, _belSerializer.nullable)(event.spanId, this.addString, true) +
-        // guid
-        (0, _belSerializer.nullable)(event.traceId, this.addString, true) +
-        // traceId
-        (0, _belSerializer.nullable)(event.spanTimestamp, _belSerializer.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 = (0, _belSerializer.addCustomAttributes)({
-          ...((0, _config.getInfo)(agentIdentifier).jsAttributes || {}),
-          ...(event.gql || {})
-        }, this.addString);
-        fields.unshift((0, _belSerializer.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;
-      };
-    }
   }
 }
 exports.Aggregate = Aggregate;

package/dist/cjs/features/ajax/instrument/index.js

@@ -33,9 +33,6 @@ class Instrument extends _instrumentBase.InstrumentBase {
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME, auto);
-
-    // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
-    if (!(0, _config.getRuntime)(agentIdentifier).xhrWrappable) return;
     this.dt = new _distributedTracing.DT(agentIdentifier);
     this.handler = (type, args, ctx, group) => (0, _handle.handle)(type, args, ctx, group, this.ee);
 

package/dist/cjs/features/jserrors/aggregate/index.js

@@ -42,13 +42,9 @@ class Aggregate extends _aggregateBase.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;
-    });
     (0, _registerHandler.registerHandler)('err', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
@@ -94,11 +90,7 @@ class Aggregate extends _aggregateBase.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;
@@ -172,14 +164,14 @@ class Aggregate extends _aggregateBase.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 = (0, _stringHashCode.stringHashCode)("".concat(stackInfo.name, "_").concat(stackInfo.message, "_").concat(stackInfo.stackString));
+    var bucketHash = (0, _stringHashCode.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 = (0, _formatStackTrace.truncateSize)(stackInfo.stackString);
@@ -198,9 +190,8 @@ class Aggregate extends _aggregateBase.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
@@ -293,5 +284,27 @@ class Aggregate extends _aggregateBase.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;
+      });
+    }
+  }
 }
 exports.Aggregate = Aggregate;

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

@@ -103,14 +103,14 @@ class Aggregate extends _aggregateBase.AggregateBase {
         // Navigation Timing level 2 API that replaced PerformanceTiming & PerformanceNavigation
         const navTimingEntry = _runtime.globalScope?.performance?.getEntriesByType('navigation')?.[0];
         const perf = {
-          timing: (0, _navTiming.addPT)(agentRuntime.offset, navTimingEntry, {}),
+          timing: (0, _navTiming.addPT)(_runtime.originTime, navTimingEntry, {}),
           navigation: (0, _navTiming.addPN)(navTimingEntry, {})
         };
         queryParameters.perf = (0, _stringify.stringify)(perf);
       } else if (typeof PerformanceTiming !== 'undefined') {
         // Safari pre-15 did not support level 2 timing
         const perf = {
-          timing: (0, _navTiming.addPT)(agentRuntime.offset, _runtime.globalScope.performance.timing, {}, true),
+          timing: (0, _navTiming.addPT)(_runtime.originTime, _runtime.globalScope.performance.timing, {}, true),
           navigation: (0, _navTiming.addPN)(_runtime.globalScope.performance.navigation, {})
         };
         queryParameters.perf = (0, _stringify.stringify)(perf);
@@ -142,7 +142,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
           return;
         }
         try {
-          const timeKeeper = new _timeKeeper.TimeKeeper();
+          const timeKeeper = new _timeKeeper.TimeKeeper(this.agentIdentifier);
           timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime);
           if (!timeKeeper.ready) throw new Error('TimeKeeper not ready');
           agentRuntime.timeKeeper = timeKeeper;

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

@@ -57,9 +57,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
     /** set at BCS response, stored in runtime */
     this.timeKeeper = undefined;
     this.recorder = args?.recorder;
-    this.preloaded = !!this.recorder;
     this.errorNoticed = args?.errorNoticed || false;
     (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    this.ee.on("cfc.".concat(_features.FEATURE_NAMES.jserrors), crossFeatureData => {
+      crossFeatureData.hasReplay = !!(this.scheduler?.started && this.recorder && this.mode === _constants3.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(_constants3.SESSION_EVENTS.RESET, () => {
@@ -106,6 +108,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.PAUSE, () => {
       this.forceStop(this.mode !== _constants3.MODE.ERROR);
     }, this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, e => {
+      this.handleError(e);
+    }, this.featureName, this.ee);
     const {
       error_sampling_rate,
       sampling_rate,
@@ -154,15 +159,17 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
   }
   switchToFull() {
+    if (!this.entitled || this.blocked) return;
     this.mode = _constants3.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);
     }
   }
 
@@ -223,7 +230,6 @@ class Aggregate extends _aggregateBase.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 === _constants3.MODE.ERROR && this.errorNoticed) this.mode = _constants3.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.
@@ -317,7 +323,7 @@ class Aggregate extends _aggregateBase.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);
   }
@@ -367,6 +373,7 @@ class Aggregate extends _aggregateBase.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/cjs/features/session_replay/constants.js

@@ -10,7 +10,8 @@ const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.sessionRepla
 const SR_EVENT_EMITTER_TYPES = exports.SR_EVENT_EMITTER_TYPES = {
   RECORD: 'recordReplay',
   PAUSE: 'pauseReplay',
-  REPLAY_RUNNING: 'replayRunning'
+  REPLAY_RUNNING: 'replayRunning',
+  ERROR_DURING_REPLAY: 'errorDuringReplay'
 };
 const AVG_COMPRESSION = exports.AVG_COMPRESSION = 0.12;
 const RRWEB_EVENT_TYPES = exports.RRWEB_EVENT_TYPES = {

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Instrument = void 0;
+var _handle = require("../../../common/event-emitter/handle");
 var _constants = require("../../../common/session/constants");
 var _instrumentBase = require("../../utils/instrument-base");
 var _constants2 = require("../constants");
@@ -25,19 +26,28 @@ class Instrument extends _instrumentBase.InstrumentBase {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, _constants2.FEATURE_NAME, auto);
     let session;
+    this.replayRunning = false;
     try {
       session = JSON.parse(localStorage.getItem("".concat(_constants.PREFIX, "_").concat(_constants.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;
+        (0, _handle.handle)(_constants2.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(_constants2.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.

package/dist/cjs/features/session_replay/shared/recorder.js

@@ -103,11 +103,10 @@ class Recorder {
       collectFonts: collect_fonts,
       checkoutEveryNms: _constants.CHECKOUT_MS[this.parent.mode]
     });
-    this.parent.ee.emit(_constants.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode]);
     this.stopRecording = () => {
       this.recording = false;
       this.parent.ee.emit(_constants.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [false, this.parent.mode]);
-      stop();
+      stop?.();
     };
   }
 
@@ -150,6 +149,10 @@ class Recorder {
     if (!event) return;
     if (!this.parent.scheduler && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1];else this.currentBufferTarget = this.#events;
     if (this.parent.blocked) return;
+    if (!this.notified) {
+      this.parent.ee.emit(_constants.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode]);
+      this.notified = true;
+    }
     if (this.parent.timeKeeper?.ready && !event.__newrelic) {
       event.__newrelic = (0, _utils.buildNRMetaNode)(event.timestamp, this.parent.timeKeeper);
       event.timestamp = this.parent.timeKeeper.correctAbsoluteTimestamp(event.timestamp);
@@ -180,7 +183,7 @@ class Recorder {
 
     // 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 > _constants.IDEAL_PAYLOAD_SIZE && this.parent.mode !== _constants2.MODE.ERROR) {
+    if ((event.type === _constants.RRWEB_EVENT_TYPES.FullSnapshot && this.currentBufferTarget.hasMeta || payloadSize > _constants.IDEAL_PAYLOAD_SIZE) && this.parent.mode === _constants2.MODE.FULL) {
       // if we've made it to the ideal size of ~64kb before the interval timer, we should send early.
       if (this.parent.scheduler) {
         this.parent.scheduler.runHarvest();