@newrelic/browser-agent 1.239.1 → 1.241.0

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

@@ -14,6 +14,7 @@ var _aggregateBase = require("../../utils/aggregate-base");
 var _sharedChannel = require("../../../common/constants/shared-channel");
 var _encode = require("../../../common/url/encode");
 var _console = require("../../../common/util/console");
+var _runtime = require("../../../common/constants/runtime");
 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.
@@ -72,17 +73,30 @@ class Aggregate extends _aggregateBase.AggregateBase {
      * -- When visibility changes from "hidden" -> "visible", it must capture a full snapshot for the replay to work correctly across tabs
     */
     this.hasSnapshot = false;
+    /** Payload metadata -- Should indicate that the payload being sent has a meta node. The meta node should always precede a snapshot node. */
+    this.hasMeta = false;
     /** Payload metadata -- Should indicate that the payload being sent contains an error.  Used for query/filter purposes in UI */
     this.hasError = false;
 
-    /** Payload metadata -- Should indicate when a replay blob started recording.  Resets each time a harvest occurs. */
+    /** 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.timestamp = {
-      first: undefined,
-      last: undefined
+      event: {
+        first: undefined,
+        last: undefined
+      },
+      cycle: {
+        first: undefined,
+        last: undefined
+      }
     };
 
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     this.payloadBytesEstimation = 0;
+
+    /** Hold on to the last meta node, so that it can be re-inserted if the meta and snapshot nodes are broken up due to harvesting */
+    this.lastMeta = undefined;
     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 */
@@ -132,7 +146,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       }, 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'));
+        return this.initializeRecording(flagOn, Math.random() * 100 < (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay.error_sampling_rate'), Math.random() * 100 < (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay.sampling_rate'));
       }).then(() => _sharedChannel.sharedChannel.onReplayReady(this.mode)); // notify watchers that replay started with the mode
 
       this.drain();
@@ -173,6 +187,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (this.mode === _sessionEntity.MODE.ERROR && this.errorNoticed) {
       this.mode = _sessionEntity.MODE.FULL;
     }
+    try {
+      // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
+      recorder = (await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "recorder" */'rrweb')))).record;
+    } catch (err) {
+      return this.abort();
+    }
 
     // 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.
@@ -181,12 +201,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
       // We only report (harvest) in FULL mode
       this.scheduler.startTimer(this.harvestTimeSeconds);
     }
-    try {
-      // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
-      recorder = (await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "recorder" */'rrweb')))).record;
-    } catch (err) {
-      return this.abort();
-    }
     try {
       // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
       const {
@@ -221,6 +235,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
   getHarvestContents() {
     const agentRuntime = (0, _config.getRuntime)(this.agentIdentifier);
     const info = (0, _config.getInfo)(this.agentIdentifier);
+    const firstTimestamp = this.timestamp.event.first || this.timestamp.cycle.first;
+    const lastTimestamp = this.timestamp.event.last || this.timestamp.cycle.last;
     return {
       qs: {
         browser_monitoring_key: info.licenseKey,
@@ -231,11 +247,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
           ...(this.shouldCompress && {
             content_encoding: 'gzip'
           }),
-          'replay.firstTimestamp': this.timestamp.first,
-          'replay.lastTimestamp': this.timestamp.last,
-          'replay.durationMs': this.timestamp.last - this.timestamp.first,
+          'replay.firstTimestamp': firstTimestamp,
+          'replay.lastTimestamp': lastTimestamp,
+          'replay.durationMs': lastTimestamp - firstTimestamp,
           agentVersion: agentRuntime.version,
           session: agentRuntime.session.state.value,
+          hasMeta: this.hasMeta,
           hasSnapshot: this.hasSnapshot,
           hasError: this.hasError,
           isFirstChunk: this.isFirstChunk,
@@ -260,6 +277,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.events = [];
     this.isFirstChunk = false;
     this.hasSnapshot = false;
+    this.hasMeta = false;
     this.hasError = false;
     this.payloadBytesEstimation = 0;
     this.clearTimestamps();
@@ -271,27 +289,30 @@ class Aggregate extends _aggregateBase.AggregateBase {
       (0, _console.warn)('Recording library was never imported');
       return this.abort();
     }
+    this.clearTimestamps();
+    // set the fallbacks as early as possible
+    this.setTimestamps();
     this.recording = true;
     const {
-      blockClass,
-      ignoreClass,
-      maskTextClass,
-      blockSelector,
-      maskInputOptions,
-      maskTextSelector,
-      maskAllInputs
+      block_class,
+      ignore_class,
+      mask_text_class,
+      block_selector,
+      mask_input_options,
+      mask_text_selector,
+      mask_all_inputs
     } = (0, _config.getConfigurationValue)(this.agentIdentifier, 'session_replay');
     // 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({
       emit: this.store.bind(this),
-      blockClass,
-      ignoreClass,
-      maskTextClass,
-      blockSelector,
-      maskInputOptions,
-      maskTextSelector,
-      maskAllInputs,
+      blockClass: block_class,
+      ignoreClass: ignore_class,
+      maskTextClass: mask_text_class,
+      blockSelector: block_selector,
+      maskInputOptions: mask_input_options,
+      maskTextSelector: mask_text_selector,
+      maskAllInputs: mask_all_inputs,
       checkoutEveryNms: CHECKOUT_MS[this.mode]
     });
     this.stopRecording = () => {
@@ -302,6 +323,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
   /** Store a payload in the buffer (this.events).  This should be the callback to the recording lib noticing a mutation */
   store(event, isCheckout) {
+    this.setTimestamps(event);
     if (this.blocked) return;
     const eventBytes = (0, _stringify.stringify)(event).length;
     /** The estimated size of the payload after compression */
@@ -318,8 +340,22 @@ class Aggregate extends _aggregateBase.AggregateBase {
       // we are still waiting for an error to throw, so keep wiping the buffer over time
       this.clearBuffer();
     }
-    this.setTimestamps(event);
-    if (event.type === 2) this.hasSnapshot = true;
+
+    // meta event
+    if (event.type === 4) {
+      this.hasMeta = true;
+      this.lastMeta = event;
+    }
+    // snapshot event
+    if (event.type === 2) {
+      this.hasSnapshot = true;
+      // small chance that the meta event got separated from its matching snapshot across payload harvests
+      // it needs to precede the snapshot, so shove it in first.
+      if (!this.hasMeta) {
+        this.events.push(this.lastMeta);
+        this.hasMeta = true;
+      }
+    }
     this.events.push(event);
     this.payloadBytesEstimation += eventBytes;
 
@@ -336,15 +372,25 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (!recorder) return;
     recorder.takeFullSnapshot();
   }
-  setTimestamps(rrwebEvent) {
-    if (!rrwebEvent) return;
-    if (!this.timestamp.first) this.timestamp.first = rrwebEvent.timestamp;
-    this.timestamp.last = rrwebEvent.timestamp;
+  setTimestamps(event) {
+    // fallbacks if timestamps cannot be derived from rrweb events
+    this.timestamp.cycle.last = (0, _config.getRuntime)(this.agentIdentifier).offset + _runtime.globalScope.performance.now();
+    if (!this.timestamp.cycle.first) this.timestamp.cycle.first = this.timestamp.cycle.last;
+    // timestamps based on rrweb events
+    if (!event || !event.timestamp) return;
+    if (!this.timestamp.event.first) this.timestamp.event.first = event.timestamp;
+    this.timestamp.event.last = event.timestamp;
   }
   clearTimestamps() {
     this.timestamp = {
-      first: undefined,
-      last: undefined
+      event: {
+        first: undefined,
+        last: undefined
+      },
+      cycle: {
+        first: undefined,
+        last: undefined
+      }
     };
   }
 

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

@@ -492,9 +492,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
       // if PO isn't supported, this checks resourcetiming buffer every harvest.
       this.storeResources(window.performance.getEntriesByType('resource'));
     }
+    let earliestTimeStamp = Infinity;
     const stns = Object.entries(this.trace).flatMap(_ref3 => {
       let [name, listOfSTNodes] = _ref3;
       // basically take the "this.trace" map-obj and concat all the list-type values
+      const oldestNodeTS = listOfSTNodes.reduce((acc, next) => !acc || next.s < acc ? next.s : acc, undefined);
+      if (oldestNodeTS < earliestTimeStamp) earliestTimeStamp = oldestNodeTS;
       if (!(name in toAggregate)) return listOfSTNodes;
       // Special processing for event nodes dealing with user inputs:
       const reindexByOriginFn = this.smearEvtsByOrigin(name);
@@ -509,8 +512,17 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.nodeCount = 0;
     return {
       qs: {
-        st: String((0, _config.getRuntime)(this.agentIdentifier).offset)
+        st: this.agentRuntime.offset,
+        /** hr === "hasReplay" in NR1, standalone is always checked and processed before harvesting
+         * so a race condition between ST and SR states should not be a concern if implemented here */
+        hr: Number(!this.isStandalone),
+        /** fts === "firstTimestamp" in NR1, indicates what the earliest NODE timestamp was
+         * so that blob parsing doesn't need to happen to support UI/API functions  */
+        fts: this.agentRuntime.offset + earliestTimeStamp,
+        /** n === "nodeCount" in NR1, a count of nodes in the ST payload, so that blob parsing doesn't need to happen to support UI/API functions */
+        n: stns.length // node count
       },
+
       body: {
         res: stns
       }

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

@@ -10,7 +10,6 @@ var _denyList = require("../../../common/deny-list/deny-list");
 var _mapOwn = require("../../../common/util/map-own");
 var _navTiming = require("../../../common/timing/nav-timing");
 var _uniqueId = require("../../../common/ids/unique-id");
-var _paintMetrics = require("../../../common/metrics/paint-metrics");
 var _interaction = require("./interaction");
 var _config = require("../../../common/config/config");
 var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
@@ -20,6 +19,8 @@ var _contextualEe = require("../../../common/event-emitter/contextual-ee");
 var CONSTANTS = _interopRequireWildcard(require("../constants"));
 var _features = require("../../../loaders/features/features");
 var _aggregateBase = require("../../utils/aggregate-base");
+var _firstContentfulPaint = require("../../../common/vitals/first-contentful-paint");
+var _firstPaint = require("../../../common/vitals/first-paint");
 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; }
 /*
@@ -662,8 +663,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
       // assign unique id, this is serialized and used to link interactions with errors
       interaction.root.attrs.id = (0, _uniqueId.generateUuid)();
       if (interaction.root.attrs.trigger === 'initialPageLoad') {
-        interaction.root.attrs.firstPaint = _paintMetrics.paintMetrics['first-paint'];
-        interaction.root.attrs.firstContentfulPaint = _paintMetrics.paintMetrics['first-contentful-paint'];
+        interaction.root.attrs.firstPaint = _firstPaint.firstPaint.current.value;
+        interaction.root.attrs.firstContentfulPaint = _firstContentfulPaint.firstContentfulPaint.current.value;
       }
       baseEE.emit('interactionSaved', [interaction]);
       state.interactionsToHarvest.push(interaction);

package/dist/cjs/loaders/agent.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Agent = void 0;
+require("./configure/public-path.npm");
 var _agentBase = require("./agent-base");
 var _enabledFeatures = require("./features/enabled-features");
 var _configure = require("./configure/configure");
@@ -17,6 +18,8 @@ var _config = require("../common/config/config");
 var _console = require("../common/util/console");
 var _stringify = require("../common/util/stringify");
 var _runtime = require("../common/constants/runtime");
+// important side effects
+
 // loader files
 
 // required features

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

@@ -132,6 +132,8 @@ function setAPI(agentIdentifier, forceDrain) {
   };
   apiInterface.start = features => {
     try {
+      const smTag = !features ? 'undefined' : 'defined';
+      (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ["API/start/".concat(smTag, "/called")], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
       const featNames = Object.values(_features.FEATURE_NAMES);
       if (features === undefined) features = featNames;else {
         features = Array.isArray(features) && features.length ? features : [features];

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

@@ -18,7 +18,6 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 function setAPI(agentIdentifier) {
   var instanceEE = _contextualEe.ee.get(agentIdentifier);
   var cycle = 0;
-  var scheme = (0, _config.getConfigurationValue)(agentIdentifier, 'ssl') === false ? 'http' : 'https';
   var api = {
     finished: (0, _invoke.single)(finished),
     setErrorHandler,
@@ -74,7 +73,10 @@ function setAPI(agentIdentifier) {
     cycle += 1;
     const agentInfo = (0, _config.getInfo)(agentIdentifier);
     if (!agentInfo.beacon) return;
-    var url = scheme + '://' + agentInfo.beacon + '/1/' + agentInfo.licenseKey;
+    const agentInit = (0, _config.getConfiguration)(agentIdentifier);
+    const scheme = agentInit.ssl === false ? 'http' : 'https';
+    const beacon = agentInit.proxy.beacon || agentInfo.beacon;
+    let url = "".concat(scheme, "://").concat(beacon, "/1/").concat(agentInfo.licenseKey);
     url += '?a=' + agentInfo.applicationID + '&';
     url += 't=' + requestName + '&';
     url += 'qt=' + ~~queueTime + '&';

package/dist/cjs/loaders/browser-agent.js

@@ -13,6 +13,7 @@ var _instrument5 = require("../features/ajax/instrument");
 var _instrument6 = require("../features/session_trace/instrument");
 var _instrument7 = require("../features/spa/instrument");
 var _instrument8 = require("../features/page_action/instrument");
+var _instrument9 = require("../features/session_replay/instrument");
 /**
  * An agent class with all feature modules available. Features may be disabled and enabled via runtime configuration.
  * The BrowserAgent class is the most convenient and reliable option for most use cases.
@@ -21,7 +22,7 @@ class BrowserAgent extends _agent.Agent {
   constructor(args) {
     super({
       ...args,
-      features: [_instrument5.Instrument, _instrument.Instrument, _instrument2.Instrument, _instrument6.Instrument, _instrument3.Instrument, _instrument8.Instrument, _instrument4.Instrument, _instrument7.Instrument],
+      features: [_instrument5.Instrument, _instrument.Instrument, _instrument2.Instrument, _instrument6.Instrument, _instrument3.Instrument, _instrument8.Instrument, _instrument4.Instrument, _instrument7.Instrument, _instrument9.Instrument],
       loaderType: 'browser-agent'
     });
   }

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

@@ -9,6 +9,9 @@ var _nreum = require("../../common/window/nreum");
 var _config = require("../../common/config/config");
 var _featureFlags = require("../../common/util/feature-flags");
 var _runtime = require("../../common/constants/runtime");
+var _publicPath = require("./public-path");
+let alreadySetOnce = false; // the configure() function can run multiple times in agent lifecycle
+
 function configure(agentIdentifier) {
   let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   let loaderType = arguments.length > 2 ? arguments[2] : undefined;
@@ -40,7 +43,16 @@ function configure(agentIdentifier) {
   }
   (0, _config.setInfo)(agentIdentifier, info);
   const updatedInit = (0, _config.getConfiguration)(agentIdentifier);
-  runtime.denyList = [...(updatedInit.ajax?.deny_list || []), ...(updatedInit.ajax?.block_internal ? [info.beacon, info.errorBeacon] : [])];
+  const internalTrafficList = [info.beacon, info.errorBeacon];
+  if (!alreadySetOnce) {
+    alreadySetOnce = true;
+    if (updatedInit.proxy.assets) {
+      (0, _publicPath.redefinePublicPath)(updatedInit.proxy.assets + '/'); // much like the info.beacon & init.proxy.beacon, this input should not end in a slash, but one is needed for webpack concat
+      internalTrafficList.push(updatedInit.proxy.assets);
+    }
+    if (updatedInit.proxy.beacon) internalTrafficList.push(updatedInit.proxy.beacon);
+  }
+  runtime.denyList = [...(updatedInit.ajax.deny_list || []), ...(updatedInit.ajax.block_internal ? internalTrafficList : [])];
   (0, _config.setRuntime)(agentIdentifier, runtime);
   (0, _api.setTopLevelCallers)();
   const api = (0, _api.setAPI)(agentIdentifier, forceDrain);

package/dist/cjs/loaders/configure/public-path.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.redefinePublicPath = void 0;
+// Set the default CDN or remote for fetching the assets; NPM shouldn't change this var.
+
+const redefinePublicPath = url => {
+  // There's no URL validation here, so caller should check arg if need be.
+  __webpack_public_path__ = url; // eslint-disable-line
+};
+exports.redefinePublicPath = redefinePublicPath;

package/dist/cjs/loaders/configure/public-path.npm.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.redefinePublicPath = void 0;
+const redefinePublicPath = () => {
+  // We don't support setting public path in webpack via NPM build.
+};
+exports.redefinePublicPath = redefinePublicPath;

package/dist/esm/cdn/pro.js

@@ -10,8 +10,9 @@ import { Instrument as InstrumentMetrics } from '../features/metrics/instrument'
 import { Instrument as InstrumentErrors } from '../features/jserrors/instrument';
 import { Instrument as InstrumentXhr } from '../features/ajax/instrument';
 import { Instrument as InstrumentSessionTrace } from '../features/session_trace/instrument';
+import { Instrument as InstrumentSessionReplay } from '../features/session_replay/instrument';
 import { Instrument as InstrumentPageAction } from '../features/page_action/instrument';
 new Agent({
-  features: [InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentXhr, InstrumentMetrics, InstrumentPageAction, InstrumentErrors],
+  features: [InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentSessionReplay, InstrumentXhr, InstrumentMetrics, InstrumentPageAction, InstrumentErrors],
   loaderType: 'pro'
 });

package/dist/esm/cdn/spa.js

@@ -9,9 +9,10 @@ import { Instrument as InstrumentMetrics } from '../features/metrics/instrument'
 import { Instrument as InstrumentErrors } from '../features/jserrors/instrument';
 import { Instrument as InstrumentXhr } from '../features/ajax/instrument';
 import { Instrument as InstrumentSessionTrace } from '../features/session_trace/instrument';
+import { Instrument as InstrumentSessionReplay } from '../features/session_replay/instrument';
 import { Instrument as InstrumentSpa } from '../features/spa/instrument';
 import { Instrument as InstrumentPageAction } from '../features/page_action/instrument';
 new Agent({
-  features: [InstrumentXhr, InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentMetrics, InstrumentPageAction, InstrumentErrors, InstrumentSpa],
+  features: [InstrumentXhr, InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentSessionReplay, InstrumentMetrics, InstrumentPageAction, InstrumentErrors, InstrumentSpa],
   loaderType: 'spa'
 });

package/dist/esm/common/config/state/init.js

@@ -3,12 +3,18 @@ import { gosNREUMInitializedAgents } from '../../window/nreum';
 import { getModeledObject } from './configurable';
 const model = () => {
   const hiddenState = {
-    blockSelector: '[data-nr-block]',
-    maskInputOptions: {
+    block_selector: '[data-nr-block]',
+    mask_input_options: {
       password: true
     }
   };
   return {
+    proxy: {
+      assets: undefined,
+      // if this value is set, it will be used to overwrite the webpack asset path used to fetch assets
+      beacon: undefined // likewise for the url to which we send analytics
+    },
+
     privacy: {
       cookies_enabled: true
     },
@@ -72,35 +78,37 @@ const model = () => {
       autoStart: true,
       enabled: false,
       harvestTimeSeconds: 60,
-      sampleRate: 0.1,
-      errorSampleRate: 0.1,
+      sampling_rate: 50,
+      // float from 0 - 100
+      error_sampling_rate: 50,
+      // float from 0 - 100
       // recording config settings
-      maskTextSelector: '*',
-      maskAllInputs: true,
+      mask_text_selector: '*',
+      mask_all_inputs: true,
       // these properties only have getters because they are enforcable constants and should error if someone tries to override them
-      get blockClass() {
+      get block_class() {
         return 'nr-block';
       },
-      get ignoreClass() {
+      get ignore_class() {
         return 'nr-ignore';
       },
-      get maskTextClass() {
+      get mask_text_class() {
         return 'nr-mask';
       },
       // props with a getter and setter are used to extend enforcable constants with customer input
       // we must preserve data-nr-block no matter what else the customer sets
-      get blockSelector() {
-        return hiddenState.blockSelector;
+      get block_selector() {
+        return hiddenState.block_selector;
       },
-      set blockSelector(val) {
-        hiddenState.blockSelector += ",".concat(val);
+      set block_selector(val) {
+        hiddenState.block_selector += ",".concat(val);
       },
       // password: must always be present and true no matter what customer sets
-      get maskInputOptions() {
-        return hiddenState.maskInputOptions;
+      get mask_input_options() {
+        return hiddenState.mask_input_options;
       },
-      set maskInputOptions(val) {
-        hiddenState.maskInputOptions = {
+      set mask_input_options(val) {
+        hiddenState.mask_input_options = {
           ...val,
           password: true
         };

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.239.1";
+export const VERSION = "1.241.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.239.1";
+export const VERSION = "1.241.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -15,8 +15,9 @@ export const isBrowserScope = typeof window !== 'undefined' && !!window.document
  */
 export const isWorkerScope = typeof WorkerGlobalScope !== 'undefined' && (typeof self !== 'undefined' && self instanceof WorkerGlobalScope && self.navigator instanceof WorkerNavigator || typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope && globalThis.navigator instanceof WorkerNavigator);
 export const globalScope = isBrowserScope ? window : typeof WorkerGlobalScope !== 'undefined' && (typeof self !== 'undefined' && self instanceof WorkerGlobalScope && self || typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope && globalThis);
+export const initiallyHidden = Boolean(globalScope?.document?.visibilityState === 'hidden');
 export const initialLocation = '' + globalScope?.location;
-export const isiOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
+export const isiOS = /iPad|iPhone|iPod/.test(globalScope.navigator?.userAgent);
 
 /**
  * Shared Web Workers introduced in iOS 16.0+ and n/a in 15.6-
@@ -27,7 +28,7 @@ export const isiOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
  */
 export const iOSBelow16 = isiOS && typeof SharedWorker === 'undefined';
 export const ffVersion = (() => {
-  const match = navigator.userAgent.match(/Firefox[/\s](\d+\.\d+)/);
+  const match = globalScope.navigator?.userAgent?.match(/Firefox[/\s](\d+\.\d+)/);
   if (Array.isArray(match) && match.length >= 2) {
     return +match[1];
   }
@@ -35,4 +36,5 @@ export const ffVersion = (() => {
 })();
 export const isIE = Boolean(isBrowserScope && window.document.documentMode); // deprecated property that only works in IE
 
-export const supportsSendBeacon = !!navigator.sendBeacon;
+export const supportsSendBeacon = !!globalScope.navigator?.sendBeacon;
+export const offset = Math.floor(globalScope?.performance?.timeOrigin || globalScope?.performance?.timing?.navigationStart || Date.now());

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

@@ -7,7 +7,7 @@ import { obj as encodeObj, param as encodeParam } from '../url/encode';
 import { stringify } from '../util/stringify';
 import * as submitData from '../util/submit-data';
 import { getLocation } from '../url/location';
-import { getInfo, getConfigurationValue, getRuntime } from '../config/config';
+import { getInfo, getConfigurationValue, getRuntime, getConfiguration } from '../config/config';
 import { cleanURL } from '../url/clean-url';
 import { now } from '../timing/now';
 import { eventListenerOpts } from '../event-listener/event-listener-opts';
@@ -32,7 +32,6 @@ export class Harvest extends SharedContext {
 
     this.tooManyRequestsDelay = getConfigurationValue(this.sharedContext.agentIdentifier, 'harvest.tooManyRequestsDelay') || 60;
     this.obfuscator = new Obfuscator(this.sharedContext);
-    this.getScheme = () => getConfigurationValue(this.sharedContext.agentIdentifier, 'ssl') === false ? 'http' : 'https';
     this._events = {};
   }
 
@@ -123,10 +122,13 @@ export class Harvest extends SharedContext {
       }
       return false;
     }
+    const init = getConfiguration(this.sharedContext.agentIdentifier);
+    const protocol = init.ssl === false ? 'http' : 'https';
+    const perceviedBeacon = init.proxy.beacon || info.errorBeacon;
     const endpointURLPart = endpoint !== 'rum' ? "/".concat(endpoint) : '';
-    let url = "".concat(this.getScheme(), "://").concat(info.errorBeacon).concat(endpointURLPart, "/1/").concat(info.licenseKey);
+    let url = "".concat(protocol, "://").concat(perceviedBeacon).concat(endpointURLPart, "/1/").concat(info.licenseKey);
     if (customUrl) url = customUrl;
-    if (raw) url = "".concat(this.getScheme(), "://").concat(info.errorBeacon, "/").concat(endpoint);
+    if (raw) url = "".concat(protocol, "://").concat(perceviedBeacon, "/").concat(endpoint);
     const baseParams = !raw && includeBaseParams ? this.baseQueryString() : '';
     let payloadParams = encodeObj(qs, agentRuntime.maxBytes);
     if (!submitMethod) {

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

@@ -0,0 +1,10 @@
+export const VITAL_NAMES = {
+  FIRST_PAINT: 'fp',
+  FIRST_CONTENTFUL_PAINT: 'fcp',
+  FIRST_INPUT_DELAY: 'fi',
+  LARGEST_CONTENTFUL_PAINT: 'lcp',
+  CUMULATIVE_LAYOUT_SHIFT: 'cls',
+  INTERACTION_TO_NEXT_PAINT: 'inp',
+  LONG_TASK: 'lt',
+  TIME_TO_FIRST_BYTE: 'ttfb'
+};

package/dist/esm/common/vitals/cumulative-layout-shift.js

@@ -0,0 +1,20 @@
+import { onCLS } from 'web-vitals';
+import { VITAL_NAMES } from './constants';
+import { VitalMetric } from './vital-metric';
+import { isBrowserScope } from '../constants/runtime';
+export const cumulativeLayoutShift = new VitalMetric(VITAL_NAMES.CUMULATIVE_LAYOUT_SHIFT, x => x);
+if (isBrowserScope) {
+  onCLS(_ref => {
+    let {
+      value,
+      entries
+    } = _ref;
+    if (cumulativeLayoutShift.roundingMethod(value) === cumulativeLayoutShift.current.value) return;
+    cumulativeLayoutShift.update({
+      value,
+      entries
+    });
+  }, {
+    reportAllChanges: true
+  });
+}