@newrelic/browser-agent 1.255.0 → 1.256.1

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.256.1](https://github.com/newrelic/newrelic-browser-agent/compare/v1.256.0...v1.256.1) (2024-04-15)
+
+
+### Bug Fixes
+
+* Revert "Generate PTID in Agent" ([#976](https://github.com/newrelic/newrelic-browser-agent/issues/976)) ([34b317f](https://github.com/newrelic/newrelic-browser-agent/commit/34b317fe577487af56d48861b7f256ec8d644d69))
+
+## [1.256.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.255.0...v1.256.0) (2024-04-11)
+
+
+### Features
+
+* Adjust Session Replay Error Tracking ([#951](https://github.com/newrelic/newrelic-browser-agent/issues/951)) ([91d65b5](https://github.com/newrelic/newrelic-browser-agent/commit/91d65b5b7b5b7e753a6603150fd4bb7d2543babd))
+* Allow unmasking elements with nr-unmask selectors ([#949](https://github.com/newrelic/newrelic-browser-agent/issues/949)) ([e17aa25](https://github.com/newrelic/newrelic-browser-agent/commit/e17aa25ee098115ad23a5fb9ae268a4b5769fac1))
+* Generate PTID in Agent ([#964](https://github.com/newrelic/newrelic-browser-agent/issues/964)) ([af7b676](https://github.com/newrelic/newrelic-browser-agent/commit/af7b6764f40cb1ddfb3ab2ca16d05d8e4f459f4e))
+
+
+### Bug Fixes
+
+* Resume Page Focus Now Checks Session State ([#961](https://github.com/newrelic/newrelic-browser-agent/issues/961)) ([e48af6b](https://github.com/newrelic/newrelic-browser-agent/commit/e48af6beb369daf6ddc8231daa040f0d9d204d5f))
+* stabilize timestamp corrections ([#966](https://github.com/newrelic/newrelic-browser-agent/issues/966)) ([4fbe962](https://github.com/newrelic/newrelic-browser-agent/commit/4fbe962d7b268968df96da59058e2e53c527c5eb))
+
 ## [1.255.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.254.1...v1.255.0) (2024-04-04)
 
 

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

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

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

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

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

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

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

@@ -127,7 +127,8 @@ class SessionEntity {
           this.write((0, _configurable.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/cjs/common/timer/interaction-timer.js

@@ -15,6 +15,9 @@ class InteractionTimer extends _timer.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'];
@@ -68,8 +71,19 @@ class InteractionTimer extends _timer.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/cjs/common/timing/time-keeper.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.TimeKeeper = void 0;
-var _runtime = require("../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
@@ -37,7 +36,7 @@ class TimeKeeper {
    */
   #ready = false;
   constructor() {
-    this.#originTime = _runtime.globalScope.performance.timeOrigin || _runtime.globalScope.performance.timing.navigationStart;
+    this.#originTime = Date.now() - performance.now();
   }
   get ready() {
     return this.#ready;

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

@@ -42,9 +42,13 @@ 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);
@@ -89,9 +93,16 @@ class Aggregate extends _aggregateBase.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;
   }
@@ -136,7 +147,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     return canonicalStackString;
   }
-  storeError(err, time, internal, customAttributes) {
+  storeError(err, time, internal, customAttributes, hasReplay) {
     // are we in an interaction
     time = time || (0, _now.now)();
     const agentRuntime = (0, _config.getRuntime)(this.agentIdentifier);
@@ -187,7 +198,7 @@ class Aggregate extends _aggregateBase.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';
@@ -198,7 +209,6 @@ class Aggregate extends _aggregateBase.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];
     (0, _handle.handle)('errorAgg', jsErrorEvent, undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
-    (0, _handle.handle)('errorAgg', jsErrorEvent, undefined, _features.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((0, _nreum.getNREUMInitializedAgent)(this.agentIdentifier)?.features[_features.FEATURE_NAMES.softNav]);

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

@@ -13,6 +13,7 @@ var _eventListenerOpts = require("../../../common/event-listener/event-listener-
 var _stringify = require("../../../common/util/stringify");
 var _uncaughtError = require("./uncaught-error");
 var _now = require("../../../common/timing/now");
+var _constants2 = require("../../session_replay/constants");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -21,6 +22,7 @@ var _now = require("../../../common/timing/now");
 class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants.FEATURE_NAME;
   #seenErrors = new Set();
+  #replayRunning = false;
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME, auto);
@@ -37,13 +39,16 @@ class Instrument extends _instrumentBase.InstrumentBase {
     });
     this.ee.on('internal-error', error => {
       if (!this.abortHandler) return;
-      (0, _handle.handle)('ierr', [this.#castError(error), (0, _now.now)(), true], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+      (0, _handle.handle)('ierr', [this.#castError(error), (0, _now.now)(), true, {}, this.#replayRunning], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+    });
+    this.ee.on(_constants2.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
+      this.#replayRunning = isRunning;
     });
     _runtime.globalScope.addEventListener('unhandledrejection', promiseRejectionEvent => {
       if (!this.abortHandler) return;
       (0, _handle.handle)('err', [this.#castPromiseRejectionEvent(promiseRejectionEvent), (0, _now.now)(), false, {
         unhandledPromiseRejection: 1
-      }], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+      }, this.#replayRunning], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
     }, (0, _eventListenerOpts.eventListenerOpts)(false, this.removeOnAbort?.signal));
     _runtime.globalScope.addEventListener('error', errorEvent => {
       if (!this.abortHandler) return;
@@ -56,7 +61,7 @@ class Instrument extends _instrumentBase.InstrumentBase {
         this.#seenErrors.delete(errorEvent.error);
         return;
       }
-      (0, _handle.handle)('err', [this.#castErrorEvent(errorEvent), (0, _now.now)()], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+      (0, _handle.handle)('err', [this.#castErrorEvent(errorEvent), (0, _now.now)(), false, {}, this.#replayRunning], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
     }, (0, _eventListenerOpts.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/cjs/features/session_replay/aggregate/index.js

@@ -22,6 +22,7 @@ var _stringify = require("../../../common/util/stringify");
 var _stylesheetEvaluator = require("../shared/stylesheet-evaluator");
 var _drain = require("../../../common/drain/drain");
 var _now = require("../../../common/timing/now");
+var _utils = require("../shared/utils");
 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 2023 New Relic Corporation. All rights reserved.
@@ -35,6 +36,8 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  */
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
+  mode = _constants3.MODE.OFF;
+
   // pass the recorder into the aggregator
   constructor(agentIdentifier, aggregator, args) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
@@ -48,23 +51,18 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.gzipper = undefined;
     /** populated with the u8 string lib async */
     this.u8 = undefined;
-    /** the mode to start in.  Defaults to off */
-    const {
-      session
-    } = (0, _config.getRuntime)(this.agentIdentifier);
-    this.mode = session.state.sessionReplayMode || _constants3.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;
     (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, _features.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(_constants3.SESSION_EVENTS.RESET, () => {
-      this.scheduler.runHarvest();
       this.abort(_constants.ABORT_REASONS.RESET);
     });
 
@@ -108,17 +106,6 @@ 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);
-
-    // 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
-    (0, _registerHandler.registerHandler)('errorAgg', e => {
-      this.errorNoticed = true;
-      if (this.recorder) this.recorder.currentBufferTarget.hasError = true;
-      // run once
-      if (this.mode === _constants3.MODE.ERROR && _runtime.globalScope?.document.visibilityState === 'visible') {
-        this.switchToFull();
-      }
-    }, this.featureName, this.ee);
     const {
       error_sampling_rate,
       sampling_rate,
@@ -159,6 +146,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/SamplingRate/Value', sampling_rate], undefined, _features.FEATURE_NAMES.metrics, this.ee);
     (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/ErrorSamplingRate/Value', error_sampling_rate], undefined, _features.FEATURE_NAMES.metrics, this.ee);
   }
+  handleError(e) {
+    if (this.recorder) this.recorder.currentBufferTarget.hasError = true;
+    // run once
+    if (this.mode === _constants3.MODE.ERROR && _runtime.globalScope?.document.visibilityState === 'visible') {
+      this.switchToFull();
+    }
+  }
   switchToFull() {
     this.mode = _constants3.MODE.FULL;
     // if the error was noticed AFTER the recorder was already imported....
@@ -223,12 +217,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
       } catch (err) {
         return this.abort(_constants.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 === _constants3.MODE.ERROR && this.errorNoticed) {
-      this.mode = _constants3.MODE.FULL;
-    }
+    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.
@@ -269,21 +264,39 @@ class Aggregate extends _aggregateBase.AggregateBase {
       this.recorder.clearBuffer();
       return;
     }
+    (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/Harvest/Attempts'], undefined, _features.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 (0, _stringify.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 = (0, _utils.buildNRMetaNode)(e.timestamp, this.timeKeeper);
+          output.timestamp = this.timeKeeper.correctAbsoluteTimestamp(e.timestamp);
+        }
+        return (0, _stringify.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 = (0, _utils.buildNRMetaNode)(node.timestamp, this.timeKeeper);
+        output.timestamp = this.timeKeeper.correctAbsoluteTimestamp(node.timestamp);
+        return output;
       });
       len = (0, _stringify.stringify)(payload.body).length;
       this.scheduler.opts.gzip = false;
@@ -303,6 +316,11 @@ class Aggregate extends _aggregateBase.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;
@@ -328,8 +346,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
       recorderEvents.hasMeta = !!events.find(x => x.type === _constants.RRWEB_EVENT_TYPES.Meta);
     }
     const relativeNow = (0, _now.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] || {};
@@ -364,6 +382,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
           invalidStylesheetsDetected: _stylesheetEvaluator.stylesheetEvaluator.invalidStylesheetsDetected,
           inlinedAllStylesheets: recorderEvents.inlinedAllStylesheets,
           'rrweb.version': _env.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/cjs/features/session_replay/constants.js

@@ -9,7 +9,8 @@ var _features = require("../../loaders/features/features");
 const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.sessionReplay;
 const SR_EVENT_EMITTER_TYPES = exports.SR_EVENT_EMITTER_TYPES = {
   RECORD: 'recordReplay',
-  PAUSE: 'pauseReplay'
+  PAUSE: 'pauseReplay',
+  REPLAY_RUNNING: 'replayRunning'
 };
 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

@@ -29,6 +29,11 @@ class Instrument extends _instrumentBase.InstrumentBase {
       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();
@@ -55,12 +60,14 @@ class Instrument extends _instrumentBase.InstrumentBase {
     } = await Promise.resolve().then(() => _interopRequireWildcard(require( /* 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/cjs/features/session_replay/shared/recorder-events.js

@@ -5,21 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.RecorderEvents = void 0;
 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/cjs/features/session_replay/shared/recorder.js

@@ -14,6 +14,7 @@ var _stylesheetEvaluator = require("./stylesheet-evaluator");
 var _handle = require("../../../common/event-emitter/handle");
 var _constants3 = require("../../metrics/constants");
 var _features = require("../../../loaders/features/features");
+var _utils = require("./utils");
 class Recorder {
   /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
   #events;
@@ -24,15 +25,9 @@ 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.RecorderEvents({
-      canCorrectTimestamps: !!parent.timeKeeper?.ready
-    });
-    this.#backloggedEvents = new _recorderEvents.RecorderEvents({
-      canCorrectTimestamps: !!parent.timeKeeper?.ready
-    });
-    this.#preloaded = [new _recorderEvents.RecorderEvents({
-      canCorrectTimestamps: !!parent.timeKeeper?.ready
-    })];
+    this.#events = new _recorderEvents.RecorderEvents();
+    this.#backloggedEvents = new _recorderEvents.RecorderEvents();
+    this.#preloaded = [new _recorderEvents.RecorderEvents()];
     /** True when actively recording, false when paused or stopped */
     this.recording = false;
     /** The pointer to the current bucket holding rrweb events */
@@ -49,18 +44,12 @@ 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,
@@ -71,34 +60,10 @@ 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 === _constants2.MODE.ERROR) this.#backloggedEvents = this.#events;else this.#backloggedEvents = new _recorderEvents.RecorderEvents({
-      canCorrectTimestamps: !!this.parent.timeKeeper?.ready
-    });
-    this.#events = new _recorderEvents.RecorderEvents({
-      canCorrectTimestamps: !!this.parent.timeKeeper?.ready
-    });
+    if (this.#preloaded[0]?.events.length) this.#preloaded.shift();else if (this.parent.mode === _constants2.MODE.ERROR) this.#backloggedEvents = this.#events;else this.#backloggedEvents = new _recorderEvents.RecorderEvents();
+    this.#events = new _recorderEvents.RecorderEvents();
   }
 
   /** Begin recording using configured recording lib */
@@ -116,6 +81,10 @@ class Recorder {
       inline_images,
       collect_fonts
     } = (0, _config.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 = (0, _rrweb.record)({
@@ -126,14 +95,18 @@ 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: _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();
     };
   }
@@ -177,7 +150,8 @@ 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 = (0, _utils.buildNRMetaNode)(event.timestamp, this.parent.timeKeeper);
       event.timestamp = this.parent.timeKeeper.correctAbsoluteTimestamp(event.timestamp);
     }
     event.__serialized = (0, _stringify.stringify)(event);
@@ -212,9 +186,7 @@ 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.RecorderEvents({
-          canCorrectTimestamps: !!this.parent.timeKeeper?.ready
-        }));
+        this.#preloaded.push(new _recorderEvents.RecorderEvents());
       }
     }
   }

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

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.buildNRMetaNode = buildNRMetaNode;
 exports.canImportReplayAgg = canImportReplayAgg;
 exports.enableSessionTracking = void 0;
 exports.isPreloadAllowed = isPreloadAllowed;
@@ -23,4 +24,15 @@ function isPreloadAllowed(agentId) {
 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
+}
+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)
+  };
 }