@newrelic/browser-agent 1.258.1 → 1.259.0

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.259.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.258.2...v1.259.0) (2024-05-08)
+
+
+### Features
+
+* Migrate Session Traces to Use Blob Consumer with Feature Flags ([#821](https://github.com/newrelic/newrelic-browser-agent/issues/821)) ([55b0e00](https://github.com/newrelic/newrelic-browser-agent/commit/55b0e00e9d8dce6d0cdbed978a98302d40123f3d))
+
+## [1.258.2](https://github.com/newrelic/newrelic-browser-agent/compare/v1.258.1...v1.258.2) (2024-05-07)
+
+
+### Bug Fixes
+
+* Prevent noticeError() API from running if not given an argument ([#1021](https://github.com/newrelic/newrelic-browser-agent/issues/1021)) ([c023a53](https://github.com/newrelic/newrelic-browser-agent/commit/c023a53c20a9f0f2472e1ba5ff78eb7210a906fa))
+
 ## [1.258.1](https://github.com/newrelic/newrelic-browser-agent/compare/v1.258.0...v1.258.1) (2024-05-07)
 
 

package/README.md

@@ -82,6 +82,7 @@ The following features may be disabled by adding `init` entries as shown above.
 - `metrics`
 - `page_action`
 - `page_view_timing`
+- `session_replay`
 - `session_trace`
 - `spa`
 
@@ -186,9 +187,7 @@ Please see our [official documentation](https://docs.newrelic.com/docs/browser/n
 ```
 
 ## Session Replay
-The Session Replay feature is currently in Limited Preview and only functional for customers participating in the early access program.  To request access, please visit [this link](https://newrelic.com/platform/session-replay-early-access). 
-
-Due to the sensitive nature of the feature, Session Replay has many configuration options, which are configurable in each browser application's *Application Settings* page on the New Relic site. These settings will only be accessible if you are participating in the limited preview. Additionally, you can control the sampling rates, obfuscation conditions and triggering rules of Session Replay.
+The Session Replay feature is now available for limited free use by all customers. The data collected by this feature will become billable starting May 15th, 2024. Please see the [Session Replay documentation](https://docs.newrelic.com/docs/browser/browser-monitoring/browser-pro-features/session-replay/) to get started using this new feature.
 
 ## Supported browsers
 
@@ -239,7 +238,7 @@ A lot of new frameworks support the concept of server-side rendering the pages o
 
 ## Disclaimers
 
-The session replay library shipping with this version of the browser agent is in *limited preview* and is not turned on by default. To use the feature, users will need to be part of the limited preview customer group and configure their browser application settings in the UI.
+The session replay library shipping as part of the browser agent is not turned on by default. For information on the use of this feature, see [Session Replay](#session-replay)
 
 ## Support
 

package/dist/cjs/cdn/polyfills.js

@@ -7,6 +7,7 @@ require("core-js/stable/array/flat");
 require("core-js/stable/array/flat-map");
 require("core-js/stable/array/from");
 require("core-js/stable/array/some");
+require("core-js/stable/array/find-index");
 require("core-js/stable/object/assign");
 require("core-js/stable/object/entries");
 require("core-js/stable/object/values");
@@ -19,4 +20,5 @@ require("core-js/stable/object/get-own-property-descriptors");
 require("core-js/stable/url");
 require("core-js/stable/url-search-params");
 require("core-js/stable/string/starts-with");
-require("core-js/stable/number/is-nan");
+require("core-js/stable/number/is-nan");
+require("core-js/stable/string/includes");

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.258.1";
+const VERSION = exports.VERSION = "1.259.0";
 
 /**
  * Exposes the build type of the agent

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.258.1";
+const VERSION = exports.VERSION = "1.259.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/drain/drain.js

@@ -83,7 +83,7 @@ function drain() {
 function checkCanDrainAll(agentIdentifier) {
   // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
   // that the last feature to call drain triggers drain for all features.
-  const items = [...registry[agentIdentifier]];
+  const items = Array.from(registry[agentIdentifier]);
   if (items.every(_ref => {
     let [key, values] = _ref;
     return values.staged;

package/dist/cjs/common/harvest/harvest-scheduler.js

@@ -38,7 +38,7 @@ class HarvestScheduler extends _sharedContext.SharedContext {
     this.started = false;
     this.timeoutHandle = null;
     this.aborted = false; // this controls the per-interval and final harvests for the scheduler (currently per feature specific!)
-
+    this.harvesting = false;
     this.harvest = new _harvest.Harvest(this.sharedContext);
 
     // unload if EOL mechanism fires
@@ -89,12 +89,14 @@ class HarvestScheduler extends _sharedContext.SharedContext {
   }
   runHarvest(opts) {
     if (this.aborted) return;
+    this.harvesting = true;
 
     /**
      * This is executed immediately after harvest sends the data via XHR, or if there's nothing to send. Note that this excludes on unloading / sendBeacon.
      * @param {Object} result
      */
     const cbRanAfterSend = result => {
+      this.harvesting = false;
       if (opts?.forceNoRetry) result.retry = false; // discard unsent data rather than re-queuing for next harvest attempt
       this.onHarvestFinished(opts, result);
     };
@@ -110,7 +112,7 @@ class HarvestScheduler extends _sharedContext.SharedContext {
       const retry = !opts?.unload && submitMethod === submitData.xhr;
       payload = this.opts.getPayload({
         retry,
-        opts
+        ...opts
       });
       if (!payload) {
         if (this.started) {

package/dist/cjs/features/ajax/constants.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.FEATURE_NAME = void 0;
+exports.MAX_PAYLOAD_SIZE = exports.FEATURE_NAME = void 0;
 var _features = require("../../loaders/features/features");
-const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.ajax;
+const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.ajax;
+const MAX_PAYLOAD_SIZE = exports.MAX_PAYLOAD_SIZE = 1000000;

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

@@ -140,6 +140,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     return canonicalStackString;
   }
   storeError(err, time, internal, customAttributes, hasReplay) {
+    if (!err) return;
     // are we in an interaction
     time = time || (0, _now.now)();
     const agentRuntime = (0, _config.getRuntime)(this.agentIdentifier);
@@ -197,12 +198,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
       time
     };
 
-    // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
+    // sr, stn and spa aggregators listen to this event - stn sends the error in its payload,
+    // and spa annotates the error with interaction info
     const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes];
     (0, _handle.handle)('trace-jserror', jsErrorEvent, undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return;
-    if (err.__newrelic?.[this.agentIdentifier]) {
+    if (err?.__newrelic?.[this.agentIdentifier]) {
       params._interactionId = err.__newrelic[this.agentIdentifier].interactionId;
       params._interactionNodeId = err.__newrelic[this.agentIdentifier].interactionNodeId;
     }

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

@@ -124,8 +124,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
       if (this.resourcesSent) return;
       this.resourcesSent = true; // make sure this only gets sent once
 
-      const agentRuntime = (0, _config.getRuntime)(this.agentIdentifier);
-
       // Capture SMs around network resources using the performance API to assess
       // work to split this out from the ST nodes
       // differentiate between internal+external and ajax+non-ajax
@@ -146,12 +144,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
         }
       });
 
-      // Capture SMs for session trace if active (`ptid` is set when returned by replay ingest).
-      // Retain these SMs while we are working through the session_replay feature
-      if (agentRuntime.ptid) {
-        this.storeSupportabilityMetrics('PageSession/Feature/SessionTrace/DurationMs', Math.round(performance.now()));
-      }
-
       // Capture SMs for performance markers and measures to assess the usage and possible inclusion of this
       // data in the agent for use in NR
       if (typeof performance !== 'undefined') {

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

@@ -150,7 +150,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
           (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/Failed'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
           (0, _drain.drain)(this.agentIdentifier, _features.FEATURE_NAMES.metrics, true);
           this.ee.abort();
-          (0, _console.warn)('Could not calculate New Relic server time. Agent shutting down.');
+          (0, _console.warn)('Could not calculate New Relic server time. Agent shutting down.', error);
           return;
         }
         try {

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

@@ -96,15 +96,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
       getPayload: this.prepareHarvest.bind(this),
       raw: true
     }, this);
-    (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.RECORD, () => {
-      // if it has aborted or BCS returned bad entitlements, do not allow
-      if (this.blocked || !this.entitled) return;
-      // if it isnt already (fully) initialized... initialize it
-      if (!this.recorder) this.initializeRecording(false, true, true);
-      // its been initialized and imported the recorder but its not recording (mode === off || error)
-      else if (this.mode !== _constants3.MODE.FULL) this.switchToFull();
-      // if it gets all the way to here, that means a full session is already recording... do nothing
-    }, this.featureName, this.ee);
     (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.PAUSE, () => {
       this.forceStop(this.mode !== _constants3.MODE.ERROR);
     }, this.featureName, this.ee);
@@ -122,9 +113,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
       inline_images,
       collect_fonts
     } = (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay');
-    this.waitForFlags(['sr']).then(_ref => {
-      let [flagOn] = _ref;
-      this.entitled = flagOn;
+    this.waitForFlags(['srs', 'sr']).then(_ref => {
+      let [srMode, entitled] = _ref;
+      this.entitled = !!entitled;
       if (!this.entitled) {
         (0, _drain.deregisterDrain)(this.agentIdentifier, this.featureName);
         if (this.recorder?.recording) {
@@ -134,11 +125,14 @@ class Aggregate extends _aggregateBase.AggregateBase {
         return;
       }
       this.drain();
-      this.initializeRecording(Math.random() * 100 < error_sampling_rate, Math.random() * 100 < sampling_rate);
+      this.initializeRecording(srMode);
     }).then(() => {
-      if (this.mode === _constants3.MODE.OFF) args?.recorder?.stopRecording(); // stop any conservative preload recording launched by instrument
-      _sharedChannel.sharedChannel.onReplayReady(this.mode); // notify watchers that replay started with the mode
-    });
+      if (this.mode === _constants3.MODE.OFF) {
+        this.recorder?.stopRecording(); // stop any conservative preload recording launched by instrument
+        while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.();
+      }
+      _sharedChannel.sharedChannel.onReplayReady(this.mode);
+    }); // notify watchers that replay started with the mode
 
     /** Detect if the default configs have been altered and report a SM.  This is useful to evaluate what the reasonable defaults are across a customer base over time */
     if (!autoStart) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/AutoStart/Modified'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
@@ -181,7 +175,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
    * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
    * @returns {void}
    */
-  async initializeRecording(errorSample, fullSample, ignoreSession) {
+  async initializeRecording(srMode, ignoreSession) {
     this.initialized = true;
     if (!this.entitled) return;
 
@@ -196,23 +190,17 @@ class Aggregate extends _aggregateBase.AggregateBase {
       timeKeeper
     } = (0, _config.getRuntime)(this.agentIdentifier);
     this.timeKeeper = timeKeeper;
-    if (!session.isNew && !ignoreSession) {
+    if (this.recorder?.parent.trigger === _constants.TRIGGERS.API && this.recorder?.recording) {
+      this.mode = _constants3.MODE.FULL;
+    } else if (!session.isNew && !ignoreSession) {
       // inherit the mode of the existing session
       this.mode = session.state.sessionReplayMode;
     } else {
       // The session is new... determine the mode the new session should start in
-      if (fullSample) this.mode = _constants3.MODE.FULL; // full mode has precedence over error mode
-      else if (errorSample) this.mode = _constants3.MODE.ERROR;
-      // If neither are selected, then don't record (early return)
-      else {
-        return;
-      }
-    }
-    if (this.recorder?.getEvents().type === 'preloaded') {
-      this.prepUtils().then(() => {
-        this.scheduler.runHarvest();
-      });
+      this.mode = srMode;
     }
+    // If off, then don't record (early return)
+    if (this.mode === _constants3.MODE.OFF) return;
     if (!this.recorder) {
       try {
         // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
@@ -230,13 +218,20 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
     // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
     if (this.mode === _constants3.MODE.ERROR && this.errorNoticed) this.mode = _constants3.MODE.FULL;
-
-    // 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 === _constants3.MODE.FULL && !this.scheduler.started) {
-      // We only report (harvest) in FULL mode
-      this.scheduler.startTimer(this.harvestTimeSeconds);
+    if (this.mode === _constants3.MODE.FULL) {
+      // If theres preloaded events and we are in full mode, just harvest immediately to clear up space and for consistency
+      if (this.recorder?.getEvents().type === 'preloaded') {
+        this.prepUtils().then(() => {
+          this.scheduler.runHarvest();
+        });
+      }
+      // 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.scheduler.started) {
+        // We only report (harvest) in FULL mode
+        this.scheduler.startTimer(this.harvestTimeSeconds);
+      }
     }
     await this.prepUtils();
     if (!this.recorder.recording) this.recorder.startRecording();

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.SR_EVENT_EMITTER_TYPES = exports.RRWEB_EVENT_TYPES = exports.QUERY_PARAM_PADDING = exports.MAX_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = exports.FEATURE_NAME = exports.CHECKOUT_MS = exports.AVG_COMPRESSION = exports.ABORT_REASONS = void 0;
+exports.TRIGGERS = exports.SR_EVENT_EMITTER_TYPES = exports.RRWEB_EVENT_TYPES = exports.QUERY_PARAM_PADDING = exports.MAX_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = exports.FEATURE_NAME = exports.CHECKOUT_MS = exports.AVG_COMPRESSION = exports.ABORT_REASONS = void 0;
 var _constants = require("../../common/session/constants");
 var _features = require("../../loaders/features/features");
 const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.sessionReplay;
@@ -59,4 +59,7 @@ const ABORT_REASONS = exports.ABORT_REASONS = {
   }
 };
 /** Reserved room for query param attrs */
-const QUERY_PARAM_PADDING = exports.QUERY_PARAM_PADDING = 5000;
+const QUERY_PARAM_PADDING = exports.QUERY_PARAM_PADDING = 5000;
+const TRIGGERS = exports.TRIGGERS = {
+  API: 'api'
+};

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

@@ -7,8 +7,8 @@ exports.Instrument = void 0;
 var _handle = require("../../../common/event-emitter/handle");
 var _constants = require("../../../common/session/constants");
 var _instrumentBase = require("../../utils/instrument-base");
-var _constants2 = require("../constants");
 var _utils = require("../shared/utils");
+var _constants2 = require("../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 2023 New Relic Corporation. All rights reserved.
@@ -22,6 +22,7 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  */
 class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants2.FEATURE_NAME;
+  #mode;
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, _constants2.FEATURE_NAME, auto);
@@ -30,8 +31,12 @@ class Instrument extends _instrumentBase.InstrumentBase {
     try {
       session = JSON.parse(localStorage.getItem("".concat(_constants.PREFIX, "_").concat(_constants.DEFAULT_KEY)));
     } catch (err) {}
+    if ((0, _utils.hasReplayPrerequisite)(agentIdentifier)) {
+      this.ee.on('recordReplay', () => this.#apiStartOrRestartReplay());
+    }
     if (this.#canPreloadRecorder(session)) {
-      this.#startRecording(session?.sessionReplayMode);
+      this.#mode = session?.sessionReplayMode;
+      this.#preloadStartRecording();
     } else {
       this.importAggregator();
     }
@@ -64,21 +69,56 @@ class Instrument extends _instrumentBase.InstrumentBase {
       return (0, _utils.isPreloadAllowed)(this.agentIdentifier);
     }
   }
-  async #startRecording(mode) {
-    const {
-      Recorder
-    } = await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "recorder" */'../shared/recorder')));
-    this.recorder = new Recorder({
-      mode,
-      agentIdentifier: this.agentIdentifier,
-      ee: this.ee
-    });
-    this.recorder.startRecording();
-    this.abortHandler = this.recorder.stopRecording;
+  #alreadyStarted = false;
+  /**
+   * This func is use for early pre-load recording prior to replay feature (agg) being loaded onto the page. It should only setup once, including if already called and in-progress.
+   */
+  async #preloadStartRecording(trigger) {
+    if (this.#alreadyStarted) return;
+    this.#alreadyStarted = true;
+    try {
+      const {
+        Recorder
+      } = await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "recorder" */'../shared/recorder')));
+
+      // If startReplay() has been used by this point, we must record in full mode regardless of session preload:
+      // Note: recorder starts here with w/e the mode is at this time, but this may be changed later (see #apiStartOrRestartReplay else-case)
+      this.recorder ??= new Recorder({
+        mode: this.#mode,
+        agentIdentifier: this.agentIdentifier,
+        trigger,
+        ee: this.ee
+      });
+      this.recorder.startRecording();
+      this.abortHandler = this.recorder.stopRecording;
+    } catch (e) {}
     this.importAggregator({
       recorder: this.recorder,
       errorNoticed: this.errorNoticed
     });
   }
+
+  /**
+   * Called whenever startReplay API is used. That could occur any time, pre or post load.
+   */
+  #apiStartOrRestartReplay() {
+    if (this.featAggregate) {
+      // post-load; there's possibly already an ongoing recording
+      if (this.featAggregate.mode !== _constants.MODE.FULL) this.featAggregate.initializeRecording(_constants.MODE.FULL, true);
+    } else {
+      // pre-load
+      this.#mode = _constants.MODE.FULL;
+      this.#preloadStartRecording(_constants2.TRIGGERS.API);
+      // There's a race here wherein either:
+      // a. Recorder has not been initialized, and we've set the enforced mode, so we're good, or;
+      // b. Record has been initialized, possibly with the "wrong" mode, so we have to correct that + restart.
+      if (this.recorder && this.recorder.parent.mode !== _constants.MODE.FULL) {
+        this.recorder.parent.mode = _constants.MODE.FULL;
+        this.recorder.stopRecording();
+        this.recorder.startRecording();
+        this.abortHandler = this.recorder.stopRecording;
+      }
+    }
+  }
 }
 exports.Instrument = Instrument;

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

@@ -5,17 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.buildNRMetaNode = buildNRMetaNode;
 exports.canImportReplayAgg = canImportReplayAgg;
-exports.enableSessionTracking = enableSessionTracking;
+exports.hasReplayPrerequisite = hasReplayPrerequisite;
 exports.isPreloadAllowed = isPreloadAllowed;
 var _config = require("../../../common/config/config");
+var _featureGates = require("../../utils/feature-gates");
 var _runtime = require("../../../common/constants/runtime");
-function enableSessionTracking(agentId) {
-  return _runtime.isBrowserScope && (0, _config.getConfigurationValue)(agentId, 'privacy.cookies_enabled') === true;
-}
 function hasReplayPrerequisite(agentId) {
   return !!_config.originals.MO &&
   // Session Replay cannot work without Mutation Observer
-  enableSessionTracking(agentId) &&
+  (0, _featureGates.canEnableSessionTracking)(agentId) &&
   // requires session tracking to be running (hence "session" replay...)
   (0, _config.getConfigurationValue)(agentId, 'session_trace.enabled') === true; // Session Replay as of now is tightly coupled with Session Trace in the UI
 }