@newrelic/browser-agent 1.255.0 → 1.256.1

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/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.1";
 
 /**
  * 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.1";
 
 /**
  * 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/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

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

@@ -1,6 +1,6 @@
 import { record as recorder } from 'rrweb';
 import { stringify } from '../../../common/util/stringify';
-import { AVG_COMPRESSION, CHECKOUT_MS, IDEAL_PAYLOAD_SIZE, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES } from '../constants';
+import { AVG_COMPRESSION, CHECKOUT_MS, IDEAL_PAYLOAD_SIZE, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES } from '../constants';
 import { getConfigurationValue } from '../../../common/config/config';
 import { RecorderEvents } from './recorder-events';
 import { MODE } from '../../../common/session/constants';
@@ -8,6 +8,7 @@ import { stylesheetEvaluator } from './stylesheet-evaluator';
 import { handle } from '../../../common/event-emitter/handle';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { buildNRMetaNode } from './utils';
 export class Recorder {
   /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
   #events;
@@ -18,15 +19,9 @@ export class Recorder {
   /** flag that if true, blocks events from being "stored".  Only set to true when a full snapshot has incomplete nodes (only stylesheets ATM) */
   #fixing = false;
   constructor(parent) {
-    this.#events = new RecorderEvents({
-      canCorrectTimestamps: !!parent.timeKeeper?.ready
-    });
-    this.#backloggedEvents = new RecorderEvents({
-      canCorrectTimestamps: !!parent.timeKeeper?.ready
-    });
-    this.#preloaded = [new RecorderEvents({
-      canCorrectTimestamps: !!parent.timeKeeper?.ready
-    })];
+    this.#events = new RecorderEvents();
+    this.#backloggedEvents = new RecorderEvents();
+    this.#preloaded = [new RecorderEvents()];
     /** True when actively recording, false when paused or stopped */
     this.recording = false;
     /** The pointer to the current bucket holding rrweb events */
@@ -43,18 +38,12 @@ export class Recorder {
     this.stopRecording = () => {/* no-op until set by rrweb initializer */};
   }
   getEvents() {
-    if (this.#preloaded[0]?.events.length) {
-      const preloadedEvents = this.returnCorrectTimestamps(this.#preloaded[0]);
-      return {
-        ...this.#preloaded[0],
-        events: preloadedEvents,
-        type: 'preloaded'
-      };
-    }
-    const backloggedEvents = this.returnCorrectTimestamps(this.#backloggedEvents);
-    const events = this.returnCorrectTimestamps(this.#events);
+    if (this.#preloaded[0]?.events.length) return {
+      ...this.#preloaded[0],
+      type: 'preloaded'
+    };
     return {
-      events: [...backloggedEvents, ...events].filter(x => x),
+      events: [...this.#backloggedEvents.events, ...this.#events.events].filter(x => x),
       type: 'standard',
       cycleTimestamp: Math.min(this.#backloggedEvents.cycleTimestamp, this.#events.cycleTimestamp),
       payloadBytesEstimation: this.#backloggedEvents.payloadBytesEstimation + this.#events.payloadBytesEstimation,
@@ -65,34 +54,10 @@ export class Recorder {
     };
   }
 
-  /**
-   * Returns time-corrected events. If the events were correctable from the beginning, this correction will have already been applied.
-   * @param {SessionReplayEvent[]} events The array of buffered SR nodes
-   * @returns {CorrectedSessionReplayEvent[]}
-   */
-  returnCorrectTimestamps(events) {
-    if (!this.parent.timeKeeper?.ready) return events.events;
-    return events.canCorrectTimestamps ? events.events : events.events.map(_ref => {
-      let {
-        __serialized,
-        timestamp,
-        ...e
-      } = _ref;
-      return {
-        timestamp: this.parent.timeKeeper.correctAbsoluteTimestamp(timestamp),
-        ...e
-      };
-    });
-  }
-
   /** Clears the buffer (this.#events), and resets all payload metadata properties */
   clearBuffer() {
-    if (this.#preloaded[0]?.events.length) this.#preloaded.shift();else if (this.parent.mode === MODE.ERROR) this.#backloggedEvents = this.#events;else this.#backloggedEvents = new RecorderEvents({
-      canCorrectTimestamps: !!this.parent.timeKeeper?.ready
-    });
-    this.#events = new RecorderEvents({
-      canCorrectTimestamps: !!this.parent.timeKeeper?.ready
-    });
+    if (this.#preloaded[0]?.events.length) this.#preloaded.shift();else if (this.parent.mode === MODE.ERROR) this.#backloggedEvents = this.#events;else this.#backloggedEvents = new RecorderEvents();
+    this.#events = new RecorderEvents();
   }
 
   /** Begin recording using configured recording lib */
@@ -110,6 +75,10 @@ export class Recorder {
       inline_images,
       collect_fonts
     } = getConfigurationValue(this.parent.agentIdentifier, 'session_replay');
+    const customMasker = (text, element) => {
+      if (element?.type?.toLowerCase() !== 'password' && (element?.dataset.nrUnmask !== undefined || element?.classList.contains('nr-unmask'))) return text;
+      return '*'.repeat(text.length);
+    };
     // set up rrweb configurations for maximum privacy --
     // https://newrelic.atlassian.net/wiki/spaces/O11Y/pages/2792293280/2023+02+28+Browser+-+Session+Replay#Configuration-options
     const stop = recorder({
@@ -120,14 +89,18 @@ export class Recorder {
       blockSelector: block_selector,
       maskInputOptions: mask_input_options,
       maskTextSelector: mask_text_selector,
+      maskTextFn: customMasker,
       maskAllInputs: mask_all_inputs,
+      maskInputFn: customMasker,
       inlineStylesheet: inline_stylesheet,
       inlineImages: inline_images,
       collectFonts: collect_fonts,
       checkoutEveryNms: CHECKOUT_MS[this.parent.mode]
     });
+    this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode]);
     this.stopRecording = () => {
       this.recording = false;
+      this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [false, this.parent.mode]);
       stop();
     };
   }
@@ -171,7 +144,8 @@ export 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.currentBufferTarget.canCorrectTimestamps) {
+    if (this.parent.timeKeeper?.ready && !event.__newrelic) {
+      event.__newrelic = buildNRMetaNode(event.timestamp, this.parent.timeKeeper);
       event.timestamp = this.parent.timeKeeper.correctAbsoluteTimestamp(event.timestamp);
     }
     event.__serialized = stringify(event);
@@ -206,9 +180,7 @@ export class Recorder {
         this.parent.scheduler.runHarvest();
       } else {
         // we are still in "preload" and it triggered a "stop point".  Make a new set, which will get pointed at on next cycle
-        this.#preloaded.push(new RecorderEvents({
-          canCorrectTimestamps: !!this.parent.timeKeeper?.ready
-        }));
+        this.#preloaded.push(new RecorderEvents());
       }
     }
   }

package/dist/esm/features/session_replay/shared/utils.js

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

package/dist/esm/loaders/api/api.js

@@ -15,6 +15,7 @@ import { gosCDN } from '../../common/window/nreum';
 import { apiMethods, asyncApiMethods } from './api-methods';
 import { SR_EVENT_EMITTER_TYPES } from '../../features/session_replay/constants';
 import { now } from '../../common/timing/now';
+import { MODE } from '../../common/session/constants';
 export function setTopLevelCallers() {
   const nr = gosCDN();
   apiMethods.forEach(f => {
@@ -38,12 +39,17 @@ export function setTopLevelCallers() {
     return returnVals.length > 1 ? returnVals : returnVals[0];
   }
 }
+const replayRunning = {};
 export function setAPI(agentIdentifier, forceDrain) {
   let runSoftNavOverSpa = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   if (!forceDrain) registerDrain(agentIdentifier, 'api');
   const apiInterface = {};
   var instanceEE = ee.get(agentIdentifier);
   var tracerEE = instanceEE.get('tracer');
+  replayRunning[agentIdentifier] = MODE.OFF;
+  instanceEE.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
+    replayRunning[agentIdentifier] = isRunning;
+  });
   var prefix = 'api-';
   var spaPrefix = prefix + 'ixn-';
 
@@ -186,7 +192,7 @@ export function setAPI(agentIdentifier, forceDrain) {
   apiInterface.noticeError = function (err, customAttributes) {
     if (typeof err === 'string') err = new Error(err);
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/noticeError/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
-    handle('err', [err, now(), false, customAttributes], undefined, FEATURE_NAMES.jserrors, instanceEE);
+    handle('err', [err, now(), false, customAttributes, !!replayRunning[agentIdentifier]], undefined, FEATURE_NAMES.jserrors, instanceEE);
   };
 
   // theres no window.load event on non-browser scopes, lazy load immediately