@newrelic/browser-agent 1.255.0 → 1.256.0

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

@@ -57,10 +57,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
     // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
     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 = (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10;
     this.maxNodesPerHarvest = (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000;
     /**
@@ -112,9 +113,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         this.isStandalone = false;
         if (prevMode === _constants2.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(_constants2.MODE.FULL);
         }
@@ -137,7 +136,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
           sessionTraceMode: _constants2.MODE.OFF
         });
         operationalGate.permanentlyDecide(false);
-        if (mostRecentModeKnown === _constants2.MODE.FULL) this.#scheduler?.runHarvest(); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
+        if (mostRecentModeKnown === _constants2.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;
       };
@@ -156,9 +155,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
            - if trace switches to Full mode, harvest should start (prev: Error) if not already running (prev: Full). */
           this.ee.on(_constants2.SESSION_EVENTS.RESUME, () => {
             const updatedTraceMode = sessionEntity.state.sessionTraceMode;
-            if (updatedTraceMode === _constants2.MODE.OFF) stopTracePerm();else if (updatedTraceMode === _constants2.MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({
-              needResponse: true
-            });
+            if (updatedTraceMode === _constants2.MODE.OFF) stopTracePerm();else if (updatedTraceMode === _constants2.MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({});
             mostRecentModeKnown = updatedTraceMode;
           });
           this.ee.on(_constants2.SESSION_EVENTS.PAUSE, () => {
@@ -249,15 +246,12 @@ class Aggregate extends _aggregateBase.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);
     }
     if (result.sent && result.retry && this.sentTrace) {
@@ -273,15 +267,18 @@ class Aggregate extends _aggregateBase.AggregateBase {
   }
   #prepareHarvest(options) {
     if (this.isStandalone) {
-      if (this.ptid && (0, _now.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 ((0, _now.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

package/dist/cjs/loaders/api/api.js

@@ -18,6 +18,7 @@ var _nreum = require("../../common/window/nreum");
 var _apiMethods = require("./api-methods");
 var _constants2 = require("../../features/session_replay/constants");
 var _now = require("../../common/timing/now");
+var _constants3 = require("../../common/session/constants");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; } /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
@@ -46,12 +47,17 @@ function setTopLevelCallers() {
     return returnVals.length > 1 ? returnVals : returnVals[0];
   }
 }
+const replayRunning = {};
 function setAPI(agentIdentifier, forceDrain) {
   let runSoftNavOverSpa = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   if (!forceDrain) (0, _drain.registerDrain)(agentIdentifier, 'api');
   const apiInterface = {};
   var instanceEE = _contextualEe.ee.get(agentIdentifier);
   var tracerEE = instanceEE.get('tracer');
+  replayRunning[agentIdentifier] = _constants3.MODE.OFF;
+  instanceEE.on(_constants2.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
+    replayRunning[agentIdentifier] = isRunning;
+  });
   var prefix = 'api-';
   var spaPrefix = prefix + 'ixn-';
 
@@ -194,7 +200,7 @@ function setAPI(agentIdentifier, forceDrain) {
   apiInterface.noticeError = function (err, customAttributes) {
     if (typeof err === 'string') err = new Error(err);
     (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/noticeError/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
-    (0, _handle.handle)('err', [err, (0, _now.now)(), false, customAttributes], undefined, _features.FEATURE_NAMES.jserrors, instanceEE);
+    (0, _handle.handle)('err', [err, (0, _now.now)(), false, customAttributes, !!replayRunning[agentIdentifier]], undefined, _features.FEATURE_NAMES.jserrors, instanceEE);
   };
 
   // theres no window.load event on non-browser scopes, lazy load immediately

package/dist/cjs/loaders/configure/configure.js

@@ -60,6 +60,7 @@ function configure(agent) {
     agent.runSoftNavOverSpa &&= updatedInit.soft_navigations.enabled === true && updatedInit.feature_flags.includes('soft_nav');
   }
   runtime.denyList = [...(updatedInit.ajax.deny_list || []), ...(updatedInit.ajax.block_internal ? internalTrafficList : [])];
+  runtime.ptid = agent.agentIdentifier;
   (0, _config.setRuntime)(agent.agentIdentifier, runtime);
   if (agent.api === undefined) agent.api = (0, _api.setAPI)(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa);
   if (agent.exposed === undefined) agent.exposed = exposed;

package/dist/esm/common/constants/env.cdn.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.255.0";
+export const VERSION = "1.256.0";
 
 /**
  * Exposes the build type of the agent
@@ -22,4 +22,4 @@ export const DIST_METHOD = 'CDN';
 /**
  * Exposes the lib version of rrweb
  */
-export const RRWEB_VERSION = "2.0.0-alpha.11";
+export const RRWEB_VERSION = "2.0.0-alpha.12";

package/dist/esm/common/constants/env.npm.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.255.0";
+export const VERSION = "1.256.0";
 
 /**
  * Exposes the build type of the agent
@@ -23,4 +23,4 @@ export const DIST_METHOD = 'NPM';
 /**
  * Exposes the lib version of rrweb
  */
-export const RRWEB_VERSION = "2.0.0-alpha.11";
+export const RRWEB_VERSION = "2.0.0-alpha.12";

package/dist/esm/common/constants/runtime.js

@@ -38,4 +38,4 @@ export const ffVersion = (() => {
 export const isIE = Boolean(isBrowserScope && window.document.documentMode); // deprecated property that only works in IE
 
 export const supportsSendBeacon = !!globalScope.navigator?.sendBeacon;
-export const offset = Math.floor(globalScope?.performance?.timeOrigin || globalScope?.performance?.timing?.navigationStart || Date.now());
+export const offset = Math.floor(Date.now() - performance.now());

package/dist/esm/common/harvest/harvest.js

@@ -178,6 +178,7 @@ export class Harvest extends SharedContext {
         const cbResult = {
           sent: this.status !== 0,
           status: this.status,
+          failed: this.status === 0 || this.status >= 400,
           xhr: this,
           fullUrl
         };

package/dist/esm/common/session/session-entity.js

@@ -122,7 +122,8 @@ export class SessionEntity {
           this.write(getModeledObject(this.state, model));
         },
         ee: this.ee,
-        refreshEvents: ['click', 'keydown', 'scroll']
+        refreshEvents: ['click', 'keydown', 'scroll'],
+        readStorage: () => this.storage.get(this.lookupKey)
       }, this.state.inactiveAt - Date.now());
     } else {
       this.state.inactiveAt = Infinity;

package/dist/esm/common/timer/interaction-timer.js

@@ -9,6 +9,9 @@ export class InteractionTimer extends Timer {
     this.onRefresh = typeof opts.onRefresh === 'function' ? opts.onRefresh : () => {/* noop */};
     this.onResume = typeof opts.onResume === 'function' ? opts.onResume : () => {/* noop */};
 
+    /** used to double-check LS state at resume time */
+    this.readStorage = opts.readStorage;
+
     // used by pause/resume
     this.remainingMs = undefined;
     if (!opts.refreshEvents) opts.refreshEvents = ['click', 'keydown', 'scroll'];
@@ -62,8 +65,19 @@ export class InteractionTimer extends Timer {
     this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp);
   }
   resume() {
-    this.refresh();
-    this.onResume(); // emit resume event after state updated
+    try {
+      const lsData = this.readStorage();
+      const obj = typeof lsData === 'string' ? JSON.parse(lsData) : lsData;
+      if (isExpired(obj.expiresAt) || isExpired(obj.inactiveAt)) this.end();else {
+        this.refresh();
+        this.onResume(); // emit resume event after state updated
+      }
+    } catch (err) {
+      this.end();
+    }
+    function isExpired(timestamp) {
+      return Date.now() > timestamp;
+    }
   }
   refresh(cb, ms) {
     this.clear();

package/dist/esm/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
@@ -32,7 +30,7 @@ export class TimeKeeper {
    */
   #ready = false;
   constructor() {
-    this.#originTime = globalScope.performance.timeOrigin || globalScope.performance.timing.navigationStart;
+    this.#originTime = Date.now() - performance.now();
   }
   get ready() {
     return this.#ready;

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

@@ -37,9 +37,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', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
@@ -84,9 +88,16 @@ export class Aggregate extends AggregateBase {
     if (releaseIds !== '{}') {
       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;
   }
@@ -131,7 +142,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);
@@ -182,7 +193,7 @@ export class Aggregate extends AggregateBase {
       params.pageview = 1;
       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];
     var type = internal ? 'ierr' : 'err';
@@ -193,7 +204,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;
     const softNavInUse = Boolean(getNREUMInitializedAgent(this.agentIdentifier)?.features[FEATURE_NAMES.softNav]);

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

@@ -12,9 +12,11 @@ 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) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
@@ -31,13 +33,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);
+      }, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee);
     }, eventListenerOpts(false, this.removeOnAbort?.signal));
     globalScope.addEventListener('error', errorEvent => {
       if (!this.abortHandler) return;
@@ -50,7 +55,7 @@ export class Instrument extends InstrumentBase {
         this.#seenErrors.delete(errorEvent.error);
         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
     this.importAggregator();

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

@@ -28,8 +28,11 @@ 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);
@@ -43,23 +46,18 @@ 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;
     /** set at BCS response, stored in runtime */
     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);
     });
 
@@ -103,17 +101,6 @@ export class Aggregate extends AggregateBase {
     registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
       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,
@@ -154,6 +141,13 @@ export class Aggregate extends AggregateBase {
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/SamplingRate/Value', sampling_rate], undefined, FEATURE_NAMES.metrics, this.ee);
     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....
@@ -218,12 +212,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.
@@ -264,21 +259,39 @@ export class Aggregate extends AggregateBase {
       this.recorder.clearBuffer();
       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("[".concat(payload.body.map(e => {
-        if (e.__serialized) return e.__serialized;
-        return stringify(e);
+      payload.body = this.gzipper(this.u8("[".concat(payload.body.map(_ref2 => {
+        let {
+          __serialized,
+          ...e
+        } = _ref2;
+        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(_ref2 => {
+      payload.body = payload.body.map(_ref3 => {
         let {
           __serialized,
           ...node
-        } = _ref2;
-        return node;
+        } = _ref3;
+        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;
@@ -298,6 +311,11 @@ export class Aggregate extends AggregateBase {
     if (recorderEvents.type === 'preloaded') this.scheduler.runHarvest(opts);
     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;
@@ -323,8 +341,8 @@ export class Aggregate extends AggregateBase {
       recorderEvents.hasMeta = !!events.find(x => x.type === RRWEB_EVENT_TYPES.Meta);
     }
     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);
     const agentMetadata = agentRuntime.appMetadata?.agents?.[0] || {};
@@ -359,6 +377,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

package/dist/esm/features/session_replay/constants.js

@@ -3,7 +3,8 @@ import { FEATURE_NAMES } from '../../loaders/features/features';
 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;
 export const RRWEB_EVENT_TYPES = {

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

@@ -23,6 +23,11 @@ export class Instrument extends InstrumentBase {
       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();
@@ -49,12 +54,14 @@ export class Instrument extends InstrumentBase {
     } = await import( /* webpackChunkName: "recorder" */'../shared/recorder');
     this.recorder = new Recorder({
       mode,
-      agentIdentifier: this.agentIdentifier
+      agentIdentifier: this.agentIdentifier,
+      ee: this.ee
     });
     this.recorder.startRecording();
     this.abortHandler = this.recorder.stopRecording;
     this.importAggregator({
-      recorder: this.recorder
+      recorder: this.recorder,
+      errorNoticed: this.errorNoticed
     });
   }
 }

package/dist/esm/features/session_replay/shared/recorder-events.js

@@ -1,19 +1,11 @@
 export class RecorderEvents {
-  constructor(_ref) {
-    let {
-      canCorrectTimestamps
-    } = _ref;
+  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