@newrelic/browser-agent 1.233.1 → 1.235.0

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.RRWEB_VERSION = exports.Aggregate = void 0;
+exports.RRWEB_VERSION = exports.MAX_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = exports.Aggregate = exports.AVG_COMPRESSION = void 0;
 var _drain = require("../../../common/drain/drain");
 var _registerHandler = require("../../../common/event-emitter/register-handler");
 var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
@@ -12,6 +12,7 @@ var _stringify = require("../../../common/util/stringify");
 var _config = require("../../../common/config/config");
 var _sessionEntity = require("../../../common/session/session-entity");
 var _aggregateBase = require("../../utils/aggregate-base");
+var _sharedChannel = require("../../../common/constants/shared-channel");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } /*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       * Copyright 2023 New Relic Corporation. All rights reserved.
@@ -26,37 +27,38 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 // would be better to get this dynamically in some way
 const RRWEB_VERSION = '2.0.0-alpha.8';
 exports.RRWEB_VERSION = RRWEB_VERSION;
+const AVG_COMPRESSION = 0.12;
+exports.AVG_COMPRESSION = AVG_COMPRESSION;
 let recorder, gzipper, u8;
 
-/** The "mode" with which the session replay is recording */
-const MODE = {
-  OFF: 0,
-  FULL: 1,
-  ERROR: 2
-};
 /** Vortex caps payload sizes at 1MB */
 const MAX_PAYLOAD_SIZE = 1000000;
 /** Unloading caps around 64kb */
+exports.MAX_PAYLOAD_SIZE = MAX_PAYLOAD_SIZE;
 const IDEAL_PAYLOAD_SIZE = 64000;
 /** Interval between forcing new full snapshots in "error" mode */
+exports.IDEAL_PAYLOAD_SIZE = IDEAL_PAYLOAD_SIZE;
 const CHECKOUT_MS = 30000;
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
-
     /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
     this.events = [];
     /** The interval to harvest at.  This gets overridden if the size of the payload exceeds certain thresholds */
     this.harvestTimeSeconds = (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay.harvestTimeSeconds') || 60;
     /** Set once the recorder has fully initialized after flag checks and sampling */
     this.initialized = false;
-    /** Set once an error has been detected on the page. */
+    /** Set once an error has been detected on the page. Never unset */
     this.errorNoticed = false;
     /** The "mode" to record in.  Defaults to "OFF" until flags and sampling are checked. See "MODE" constant. */
-    this.mode = MODE.OFF;
+    this.mode = _sessionEntity.MODE.OFF;
     /** Set once the feature has been "aborted" to prevent other side-effects from continuing */
     this.blocked = false;
+    /** True when actively recording, false when paused or stopped */
+    this.recording = false;
+    /** can shut off efforts to compress the data */
+    this.shouldCompress = true;
 
     /** Payload metadata -- Should indicate that the payload being sent is the first of a session */
     this.isFirstChunk = false;
@@ -70,62 +72,61 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     this.payloadBytesEstimation = 0;
+    const shouldSetup = (0, _config.getConfigurationValue)(agentIdentifier, 'privacy.cookies_enabled') === true && (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.enabled') === true;
 
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
     this.stopRecording = () => {/* no-op until set by rrweb initializer */};
+    if (shouldSetup) {
+      // 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(_sessionEntity.SESSION_EVENTS.RESET, () => {
+        this.abort();
+      });
 
-    // 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-reset', () => {
-      this.abort();
-    });
+      // The SessionEntity class can emit a message indicating the session was paused (visibility change). This feature must stop recording if that occurs.
+      this.ee.on(_sessionEntity.SESSION_EVENTS.PAUSE, () => {
+        this.stopRecording();
+      });
+      // The SessionEntity class can emit a message indicating the session was resumed (visibility change). This feature must start running again (if already running) if that occurs.
+      this.ee.on(_sessionEntity.SESSION_EVENTS.RESUME, () => {
+        if (!this.initialized || this.mode === _sessionEntity.MODE.OFF) return;
+        this.startRecording();
+      });
 
-    // The SessionEntity class can emit a message indicating the session was paused (visibility change). This feature must stop recording if that occurs.
-    this.ee.on(_sessionEntity.SESSION_EVENTS.PAUSE, () => {
-      this.stopRecording();
-    });
-    // The SessionEntity class can emit a message indicating the session was resumed (visibility change). This feature must start running again (if already running) if that occurs.
-    this.ee.on(_sessionEntity.SESSION_EVENTS.RESUME, () => {
-      if (!this.initialized || this.mode === MODE.OFF) return;
-      this.startRecording();
-      this.takeFullSnapshot();
-    });
-
-    // Bespoke logic for new endpoint.  This will change as downstream dependencies become solidified.
-    this.scheduler = new _harvestScheduler.HarvestScheduler('blob', {
-      onFinished: this.onHarvestFinished.bind(this),
-      retryDelay: this.harvestTimeSeconds,
-      getPayload: this.prepareHarvest.bind(this),
-      raw: true
-    }, this);
+      // Bespoke logic for new endpoint.  This will change as downstream dependencies become solidified.
+      this.scheduler = new _harvestScheduler.HarvestScheduler('blob', {
+        onFinished: this.onHarvestFinished.bind(this),
+        retryDelay: this.harvestTimeSeconds,
+        getPayload: this.prepareHarvest.bind(this),
+        raw: true
+      }, this);
 
-    // 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.hasError = true;
-      // run once
-      if (this.mode === MODE.ERROR) {
-        this.mode = MODE.FULL;
-        // if the error was noticed AFTER the recorder was already imported....
-        if (recorder && this.initialized) {
-          this.stopRecording();
-          this.startRecording();
-          this.scheduler.startTimer(this.harvestTimeSeconds);
-          const {
-            session
-          } = (0, _config.getRuntime)(this.agentIdentifier);
-          session.state.sessionReplay = this.mode;
+      // 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.hasError = true;
+        this.errorNoticed = true;
+        // run once
+        if (this.mode === _sessionEntity.MODE.ERROR) {
+          this.mode = _sessionEntity.MODE.FULL;
+          // if the error was noticed AFTER the recorder was already imported....
+          if (recorder && this.initialized) {
+            this.stopRecording();
+            this.startRecording();
+            this.scheduler.startTimer(this.harvestTimeSeconds);
+            const {
+              session
+            } = (0, _config.getRuntime)(this.agentIdentifier);
+            session.state.sessionReplay = this.mode;
+          }
         }
-      }
-    }, this.featureName, this.ee);
+      }, this.featureName, this.ee);
+      this.waitForFlags(['sr']).then(_ref => {
+        let [flagOn] = _ref;
+        return this.initializeRecording(flagOn, Math.random() < (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay.errorSampleRate'), Math.random() < (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay.sampleRate'));
+      }).then(() => _sharedChannel.sharedChannel.onReplayReady(this.mode)); // notify watchers that replay started with the mode
 
-    // new handler for waiting for multiple flags.  will be useful if/when backend designs multiple flags, or for evaluating multiple feature flags simultaneously (stn vs sr)
-    this.waitForFlags(['sr']).then(_ref => {
-      let [{
-        value
-      }] = _ref;
-      this.initializeRecording(value, Math.random() < (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay.errorSampleRate'), Math.random() < (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay.sampleRate'));
-    });
-    (0, _drain.drain)(this.agentIdentifier, this.featureName);
+      (0, _drain.drain)(this.agentIdentifier, this.featureName);
+    }
   }
 
   /**
@@ -152,46 +153,53 @@ class Aggregate extends _aggregateBase.AggregateBase {
       this.mode = session.state.sessionReplay;
     } else {
       // The session is new... determine the mode the new session should start in
-      if (fullSample) this.mode = MODE.FULL; // full mode has precedence over error mode
-      else if (errorSample) this.mode = MODE.ERROR;
+      if (fullSample) this.mode = _sessionEntity.MODE.FULL; // full mode has precedence over error mode
+      else if (errorSample) this.mode = _sessionEntity.MODE.ERROR;
       // If neither are selected, then don't record (early return)
       else return;
     }
 
+    // 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 === _sessionEntity.MODE.ERROR && this.errorNoticed) {
+      this.mode = _sessionEntity.MODE.FULL;
+    }
+
     // 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.
     // If an error happened in ERROR mode before we've gotten to this stage, it will have already set the mode to FULL
-    if (this.mode === MODE.FULL) {
+    if (this.mode === _sessionEntity.MODE.FULL) {
       // We only report (harvest) in FULL mode
       this.scheduler.startTimer(this.harvestTimeSeconds);
     }
-
-    // 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;
+    try {
+      recorder = (await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "recorder" */'rrweb')))).record;
+    } catch (err) {
+      return this.abort();
+    }
+    try {
+      const {
+        gzipSync,
+        strToU8
+      } = await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "compressor" */'fflate')));
+      gzipper = gzipSync;
+      u8 = strToU8;
+    } catch (err) {
+      // compressor failed to load, but we can still record without compression as a last ditch effort
+      this.shouldCompress = false;
     }
-    // We record in FULL or ERROR mode
-
-    recorder = (await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "recorder" */'rrweb')))).record;
     this.startRecording();
-    const {
-      gzipSync,
-      strToU8
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "compressor" */'fflate')));
-    gzipper = gzipSync;
-    u8 = strToU8;
     this.isFirstChunk = !!session.isNew;
     session.state.sessionReplay = this.mode;
   }
-  prepareHarvest(options) {
+  prepareHarvest() {
     if (this.events.length === 0) return;
     const payload = this.getHarvestContents();
-    try {
+    if (this.shouldCompress) {
       payload.body = gzipper(u8((0, _stringify.stringify)(payload.body)));
       this.scheduler.opts.gzip = true;
-    } catch (err) {
-      // failed to gzip
+    } else {
       this.scheduler.opts.gzip = false;
+      delete payload.qs.content_encoding;
     }
     // TODO -- Gracefully handle the buffer for retries.
     this.clearBuffer();
@@ -258,7 +266,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.hasSnapshot = true;
     // set up rrweb configurations for maximum privacy --
     // https://newrelic.atlassian.net/wiki/spaces/O11Y/pages/2792293280/2023+02+28+Browser+-+Session+Replay#Configuration-options
-    this.stopRecording = recorder({
+    const stop = recorder({
       emit: this.store.bind(this),
       blockClass,
       ignoreClass,
@@ -267,10 +275,15 @@ class Aggregate extends _aggregateBase.AggregateBase {
       maskInputOptions,
       maskTextSelector,
       maskAllInputs,
-      ...(this.mode === MODE.ERROR && {
+      ...(this.mode === _sessionEntity.MODE.ERROR && {
         checkoutEveryNms: CHECKOUT_MS
       })
     });
+    this.recording = true;
+    this.stopRecording = () => {
+      this.recording = false;
+      stop();
+    };
   }
 
   /** Store a payload in the buffer (this.events).  This should be the callback to the recording lib noticing a mutation */
@@ -281,12 +294,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
     const payloadSize = this.getPayloadSize(eventBytes);
     // Vortex will block payloads at a certain size, we might as well not send.
     if (payloadSize > MAX_PAYLOAD_SIZE) {
+      this.clearBuffer();
       return this.abort();
     }
     // Checkout events are flags by the recording lib that indicate a fullsnapshot was taken every n ms. These are important
     // to help reconstruct the replay later and must be included.  While waiting and buffering for errors to come through,
     // each time we see a new checkout, we can drop the old data.
-    if (this.mode === MODE.ERROR && isCheckout) {
+    if (this.mode === _sessionEntity.MODE.ERROR && isCheckout) {
       // we are still waiting for an error to throw, so keep wiping the buffer over time
       this.clearBuffer();
     }
@@ -318,7 +332,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
   /** Abort the feature, once aborted it will not resume */
   abort() {
     this.blocked = true;
+    this.mode = _sessionEntity.MODE.OFF;
     this.stopRecording();
+    this.ee.emit('REPLAY_ABORTED');
     const {
       session
     } = (0, _config.getRuntime)(this.agentIdentifier);
@@ -330,7 +346,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
    * https://staging.onenr.io/037jbJWxbjy
    * */
   estimateCompression(data) {
-    return data * 0.12;
+    if (this.shouldCompress) return data * AVG_COMPRESSION;
+    return data;
   }
 }
 exports.Aggregate = Aggregate;

package/dist/cjs/features/session_replay/replay-mode.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSessionReplayMode = getSessionReplayMode;
+var _config = require("../../common/config/config");
+var _sessionEntity = require("../../common/session/session-entity");
+var _nreum = require("../../common/window/nreum");
+var _sharedChannel = require("../../common/constants/shared-channel");
+/**
+ * Figure out if the Replay feature is running (what mode it's in).
+ * IMPORTANT: Session tracking is assumed to be ON; if applicable, check init's privacy.cookies_enabled setting before using this fn!
+ * CRITICAL: This fn must be called prior to ALL features aggregate draining. If not, it will never resolve.
+ * @param {String} agentId
+ * @returns Promise that resolves to one of the values in MODE enum
+ */
+async function getSessionReplayMode(agentId) {
+  try {
+    const newrelic = (0, _nreum.gosNREUM)();
+    // Should be enabled by configuration and using an agent build that includes it (via checking that the instrument class was initialized).
+    if ((0, _config.getConfigurationValue)(agentId, 'session_replay.enabled') && typeof newrelic.initializedAgents[agentId].features.session_replay === 'object') {
+      await newrelic.initializedAgents[agentId].features.session_replay.onAggregateImported; // if Replay could not initialize, this throws a (uncaught) rejection
+      return await _sharedChannel.sharedChannel.sessionReplayInitialized; // wait for replay to determine which mode it's after running its sampling logic
+    }
+  } catch (e) {/* exception ==> off */}
+  return _sessionEntity.MODE.OFF; // at any step of the way s.t. SR cannot be on by implication or is explicitly off
+}