@newrelic/browser-agent 1.249.0 → 1.251.0

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

@@ -3,7 +3,54 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.FEATURE_NAME = void 0;
+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 = _features.FEATURE_NAMES.sessionReplay;
-exports.FEATURE_NAME = FEATURE_NAME;
+const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.sessionReplay;
+const AVG_COMPRESSION = exports.AVG_COMPRESSION = 0.12;
+const RRWEB_EVENT_TYPES = exports.RRWEB_EVENT_TYPES = {
+  DomContentLoaded: 0,
+  Load: 1,
+  FullSnapshot: 2,
+  IncrementalSnapshot: 3,
+  Meta: 4,
+  Custom: 5
+};
+/** Vortex caps payload sizes at 1MB */
+const MAX_PAYLOAD_SIZE = exports.MAX_PAYLOAD_SIZE = 1000000;
+/** Unloading caps around 64kb */
+const IDEAL_PAYLOAD_SIZE = exports.IDEAL_PAYLOAD_SIZE = 64000;
+/** Interval between forcing new full snapshots -- 15 seconds in error mode (x2), 5 minutes in full mode */
+const CHECKOUT_MS = exports.CHECKOUT_MS = {
+  [_constants.MODE.ERROR]: 15000,
+  [_constants.MODE.FULL]: 300000,
+  [_constants.MODE.OFF]: 0
+};
+const ABORT_REASONS = exports.ABORT_REASONS = {
+  RESET: {
+    message: 'Session was reset',
+    sm: 'Reset'
+  },
+  IMPORT: {
+    message: 'Recorder failed to import',
+    sm: 'Import'
+  },
+  TOO_MANY: {
+    message: '429: Too Many Requests',
+    sm: 'Too-Many'
+  },
+  TOO_BIG: {
+    message: 'Payload was too large',
+    sm: 'Too-Big'
+  },
+  CROSS_TAB: {
+    message: 'Session Entity was set to OFF on another tab',
+    sm: 'Cross-Tab'
+  },
+  ENTITLEMENTS: {
+    message: 'Session Replay is not allowed and will not be started',
+    sm: 'Entitlement'
+  }
+};
+/** Reserved room for query param attrs */
+const QUERY_PARAM_PADDING = exports.QUERY_PARAM_PADDING = 5000;

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

@@ -4,26 +4,48 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Instrument = void 0;
+var _constants = require("../../../common/session/constants");
 var _instrumentBase = require("../../utils/instrument-base");
-var _constants = require("../constants");
-/*
+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.
  * SPDX-License-Identifier: Apache-2.0
- */
-/**
+ */ /**
  * @file Primes the Session Replay feature for lazy loading.
  *
  * NOTE: This code is under development and dormant. It will not download to instrumented pages or record any data.
  * It is not production ready, and is not intended to be imported or implemented in any build of the browser agent until
  * functionality is validated and a full user experience is curated.
  */
-
 class Instrument extends _instrumentBase.InstrumentBase {
-  static featureName = _constants.FEATURE_NAME;
+  static featureName = _constants2.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    super(agentIdentifier, aggregator, _constants.FEATURE_NAME, auto);
-    this.importAggregator();
+    super(agentIdentifier, aggregator, _constants2.FEATURE_NAME, auto);
+    try {
+      const session = JSON.parse(localStorage.getItem('NRBA_SESSION'));
+      if (session.sessionReplayMode !== _constants.MODE.OFF) {
+        this.#startRecording(session.sessionReplayMode);
+      } else {
+        this.importAggregator({});
+      }
+    } catch (err) {
+      this.importAggregator({});
+    }
+  }
+  async #startRecording(mode) {
+    const {
+      Recorder
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "recorder" */'../shared/recorder')));
+    this.recorder = new Recorder({
+      mode,
+      agentIdentifier: this.agentIdentifier
+    });
+    this.recorder.startRecording();
+    this.importAggregator({
+      recorder: this.recorder
+    });
   }
 }
 exports.Instrument = Instrument;

package/dist/cjs/features/session_replay/shared/recorder-events.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RecorderEvents = void 0;
+class RecorderEvents {
+  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();
+    /** 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
+     * -- When the recording library begins recording, it starts by taking a DOM snapshot
+     * -- 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 -- Denotes whether all stylesheet elements were able to be inlined */
+    this.inlinedAllStylesheets = true;
+  }
+  add(event) {
+    this.events.push(event);
+  }
+}
+exports.RecorderEvents = RecorderEvents;

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

@@ -0,0 +1,201 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Recorder = void 0;
+var _rrweb = require("rrweb");
+var _stringify = require("../../../common/util/stringify");
+var _constants = require("../constants");
+var _config = require("../../../common/config/config");
+var _recorderEvents = require("./recorder-events");
+var _constants2 = require("../../../common/session/constants");
+var _stylesheetEvaluator = require("./stylesheet-evaluator");
+var _handle = require("../../../common/event-emitter/handle");
+var _constants3 = require("../../metrics/constants");
+var _features = require("../../../loaders/features/features");
+class Recorder {
+  /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
+  #events = new _recorderEvents.RecorderEvents();
+  /** Backlog used for a 2-part sliding window to guarantee a 15-30s buffer window */
+  #backloggedEvents = new _recorderEvents.RecorderEvents();
+  /** array of recorder events -- Will be filled only if forced harvest was triggered and harvester does not exist */
+  #preloaded = [new _recorderEvents.RecorderEvents()];
+  /** 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) {
+    /** True when actively recording, false when paused or stopped */
+    this.recording = false;
+    /** The pointer to the current bucket holding rrweb events */
+    this.currentBufferTarget = this.#events;
+    /** 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 = false;
+    /** The parent class that instantiated the recorder */
+    this.parent = parent;
+    /** Config to inform to inline stylesheet contents (true default) */
+    this.shouldInlineStylesheets = (0, _config.getConfigurationValue)(this.parent.agentIdentifier, 'session_replay.inline_stylesheet');
+    /** A flag that can be set to false by failing conversions to stop the fetching process */
+    this.shouldFix = this.shouldInlineStylesheets;
+    /** 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 */};
+  }
+  getEvents() {
+    if (this.#preloaded[0]?.events.length) return {
+      ...this.#preloaded[0],
+      type: 'preloaded'
+    };
+    return {
+      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,
+      hasError: this.#backloggedEvents.hasError || this.#events.hasError,
+      hasMeta: this.#backloggedEvents.hasMeta || this.#events.hasMeta,
+      hasSnapshot: this.#backloggedEvents.hasSnapshot || this.#events.hasSnapshot,
+      inlinedAllStylesheets: !!this.#backloggedEvents.events.length && this.#backloggedEvents.inlinedAllStylesheets || this.#events.inlinedAllStylesheets
+    };
+  }
+
+  /** 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();
+    this.#events = new _recorderEvents.RecorderEvents();
+  }
+
+  /** Begin recording using configured recording lib */
+  startRecording() {
+    this.recording = true;
+    const {
+      block_class,
+      ignore_class,
+      mask_text_class,
+      block_selector,
+      mask_input_options,
+      mask_text_selector,
+      mask_all_inputs,
+      inline_stylesheet,
+      inline_images,
+      collect_fonts
+    } = (0, _config.getConfigurationValue)(this.parent.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 = (0, _rrweb.record)({
+      emit: this.audit.bind(this),
+      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,
+      inlineStylesheet: inline_stylesheet,
+      inlineImages: inline_images,
+      collectFonts: collect_fonts,
+      checkoutEveryNms: _constants.CHECKOUT_MS[this.parent.mode]
+    });
+    this.stopRecording = () => {
+      this.recording = false;
+      stop();
+    };
+  }
+
+  /**
+   * audit - Checks if the event node payload is missing certain attributes
+   * will forward on to the "store" method if nothing needs async fixing
+   * @param {*} event - An RRWEB event node
+   * @param {*} isCheckout - Flag indicating if the payload was triggered as a checkout
+   */
+  audit(event, isCheckout) {
+    /** only run the audit if inline_stylesheets is configured as on (default behavior) */
+    if (this.shouldInlineStylesheets === false || !this.shouldFix) {
+      this.currentBufferTarget.inlinedAllStylesheets = false;
+      return this.store(event, isCheckout);
+    }
+    /** An count of stylesheet objects that were blocked from accessing contents via JS */
+    const incompletes = _stylesheetEvaluator.stylesheetEvaluator.evaluate();
+    /** Only stop ignoring data if already ignoring and a new valid snapshap is taking place (0 incompletes and we get a meta node for the snap) */
+    if (!incompletes && this.#fixing && event.type === _constants.RRWEB_EVENT_TYPES.Meta) this.#fixing = false;
+    if (incompletes) {
+      (0, _handle.handle)(_constants3.SUPPORTABILITY_METRIC_CHANNEL, ['SessionReplay/Payload/Missing-Inline-Css', incompletes], undefined, _features.FEATURE_NAMES.metrics, this.parent.ee);
+      /** wait for the evaluator to download/replace the incompletes' src code and then take a new snap */
+      _stylesheetEvaluator.stylesheetEvaluator.fix().then(failedToFix => {
+        if (failedToFix) {
+          this.currentBufferTarget.inlinedAllStylesheets = false;
+          this.shouldFix = false;
+        }
+        this.takeFullSnapshot();
+      });
+      /** Only start ignoring data if got a faulty snapshot */
+      if (event.type === _constants.RRWEB_EVENT_TYPES.FullSnapshot || event.type === _constants.RRWEB_EVENT_TYPES.Meta) this.#fixing = true;
+    }
+    /** Only store the data if not being "fixed" (full snapshots that have broken css) */
+    if (!this.#fixing) this.store(event, isCheckout);
+  }
+
+  /** Store a payload in the buffer (this.#events).  This should be the callback to the recording lib noticing a mutation */
+  store(event, isCheckout) {
+    if (!event) return;
+    event.__serialized = (0, _stringify.stringify)(event);
+    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;
+    const eventBytes = event.__serialized.length;
+    /** The estimated size of the payload after compression */
+    const payloadSize = this.getPayloadSize(eventBytes);
+    // 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.
+    // we need to check for meta because rrweb will flag it as checkout twice, once for meta, then once for snapshot
+    if (this.parent.mode === _constants2.MODE.ERROR && isCheckout && event.type === _constants.RRWEB_EVENT_TYPES.Meta) {
+      // we are still waiting for an error to throw, so keep wiping the buffer over time
+      this.clearBuffer();
+    }
+
+    // meta event
+    if (event.type === _constants.RRWEB_EVENT_TYPES.Meta) {
+      this.currentBufferTarget.hasMeta = true;
+    }
+    // snapshot event
+    if (event.type === _constants.RRWEB_EVENT_TYPES.FullSnapshot) {
+      this.currentBufferTarget.hasSnapshot = true;
+    }
+    this.currentBufferTarget.add(event);
+    this.currentBufferTarget.payloadBytesEstimation += eventBytes;
+
+    // We are making an effort to try to keep payloads manageable for unloading.  If they reach the unload limit before their interval,
+    // it will send immediately.  This often happens on the first snapshot, which can be significantly larger than the other payloads.
+    if (payloadSize > _constants.IDEAL_PAYLOAD_SIZE && this.parent.mode !== _constants2.MODE.ERROR) {
+      // if we've made it to the ideal size of ~64kb before the interval timer, we should send early.
+      if (this.parent.scheduler) {
+        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());
+      }
+    }
+  }
+
+  /** force the recording lib to take a full DOM snapshot.  This needs to occur in certain cases, like visibility changes */
+  takeFullSnapshot() {
+    _rrweb.record.takeFullSnapshot();
+  }
+  clearTimestamps() {
+    this.currentBufferTarget.cycleTimestamp = undefined;
+  }
+
+  /** Estimate the payload size */
+  getPayloadSize() {
+    let newBytes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    // the query param padding constant gives us some padding for the other metadata to be safely injected
+    return this.estimateCompression(this.currentBufferTarget.payloadBytesEstimation + newBytes) + _constants.QUERY_PARAM_PADDING;
+  }
+
+  /** Extensive research has yielded about an 88% compression factor on these payloads.
+   * This is an estimation using that factor as to not cause performance issues while evaluating
+   * https://staging.onenr.io/037jbJWxbjy
+   * */
+  estimateCompression(data) {
+    if (this.shouldCompress) return data * _constants.AVG_COMPRESSION;
+    return data;
+  }
+}
+exports.Recorder = Recorder;

package/dist/cjs/features/session_replay/{replay-mode.js → shared/replay-mode.js}

@@ -4,10 +4,10 @@ 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");
+var _config = require("../../../common/config/config");
+var _nreum = require("../../../common/window/nreum");
+var _sharedChannel = require("../../../common/constants/shared-channel");
+var _constants = require("../../../common/session/constants");
 /**
  * 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!
@@ -24,5 +24,5 @@ async function getSessionReplayMode(agentId) {
       if (srInitialized) 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
+  return _constants.MODE.OFF; // at any step of the way s.t. SR cannot be on by implication or is explicitly off
 }

package/dist/cjs/features/session_replay/shared/stylesheet-evaluator.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stylesheetEvaluator = void 0;
+var _config = require("../../../common/config/config");
+var _runtime = require("../../../common/constants/runtime");
+class StylesheetEvaluator {
+  #evaluated = new WeakSet();
+  #fetchProms = [];
+  /**
+  * Flipped to true if stylesheets that cannot be natively inlined are detected by the stylesheetEvaluator class
+  * Used at harvest time to denote that all subsequent payloads are subject to this and customers should be advised to handle crossorigin decoration
+  * */
+  invalidStylesheetsDetected = false;
+  failedToFix = false;
+
+  /**
+   * this works by checking (only ever once) each cssRules obj in the style sheets array. The try/catch will catch an error if the cssRules obj blocks access, triggering the module to try to "fix" the asset`. Returns the count of incomplete assets discovered.
+   * @returns {Number}
+   */
+  evaluate() {
+    let incompletes = 0;
+    if (_runtime.isBrowserScope) {
+      for (let i = 0; i < Object.keys(document.styleSheets).length; i++) {
+        const ss = document.styleSheets[i];
+        if (!this.#evaluated.has(ss)) {
+          this.#evaluated.add(ss);
+          try {
+            // eslint-disable-next-line
+            const temp = ss.cssRules;
+          } catch (err) {
+            incompletes++;
+            this.#fetchProms.push(this.#fetchAndOverride(document.styleSheets[i], ss.href));
+          }
+        }
+      }
+    }
+    if (incompletes) this.invalidStylesheetsDetected = true;
+    return incompletes;
+  }
+
+  /**
+   * Resolves promise once all stylesheets have been fetched and overridden
+   * @returns {Promise}
+   */
+  async fix() {
+    await Promise.all(this.#fetchProms);
+    this.#fetchProms = [];
+    const failedToFix = this.failedToFix;
+    this.failedToFix = false;
+    return failedToFix;
+  }
+
+  /**
+  * Fetches stylesheet contents and overrides the target getters
+  * @param {*} target - The stylesheet object target - ex. document.styleSheets[0]
+  * @param {*} href - The asset href to fetch
+  * @returns {Promise}
+  */
+  async #fetchAndOverride(target, href) {
+    const stylesheetContents = await _config.originals.FETCH.bind(window)(href);
+    if (!stylesheetContents.ok) {
+      this.failedToFix = true;
+      return;
+    }
+    const stylesheetText = await stylesheetContents.text();
+    try {
+      const cssSheet = new CSSStyleSheet();
+      await cssSheet.replace(stylesheetText);
+      Object.defineProperty(target, 'cssRules', {
+        get() {
+          return cssSheet.cssRules;
+        }
+      });
+      Object.defineProperty(target, 'rules', {
+        get() {
+          return cssSheet.rules;
+        }
+      });
+    } catch (err) {
+      // cant make new dynamic stylesheets, browser likely doesn't support `.replace()`...
+      // this is appended in prep of forking rrweb
+      Object.defineProperty(target, 'cssText', {
+        get() {
+          return stylesheetText;
+        }
+      });
+      this.failedToFix = true;
+    }
+  }
+}
+const stylesheetEvaluator = exports.stylesheetEvaluator = new StylesheetEvaluator();

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

@@ -11,9 +11,9 @@ var _config = require("../../../common/config/config");
 var _now = require("../../../common/timing/now");
 var _constants = require("../constants");
 var _handlerCache = require("../../utils/handler-cache");
-var _sessionEntity = require("../../../common/session/session-entity");
-var _replayMode = require("../../session_replay/replay-mode");
+var _replayMode = require("../../session_replay/shared/replay-mode");
 var _aggregateBase = require("../../utils/aggregate-base");
+var _constants2 = require("../../../common/session/constants");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -74,14 +74,14 @@ class Aggregate extends _aggregateBase.AggregateBase {
     /* --- The following section deals with user sessions concept & contains non-trivial control flow. --- */
     const controlTraceOp = traceMode => {
       switch (traceMode) {
-        case _sessionEntity.MODE.ERROR:
+        case _constants2.MODE.ERROR:
           this.startTracing(operationalGate, true);
           break;
-        case _sessionEntity.MODE.FULL:
+        case _constants2.MODE.FULL:
         case true:
           this.startTracing(operationalGate);
           break;
-        case _sessionEntity.MODE.OFF:
+        case _constants2.MODE.OFF:
         case false:
         default:
           // this feature becomes "off" (does nothing & nothing is sent)
@@ -91,9 +91,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
     };
     let seenAnError = false;
     let mostRecentModeKnown;
-    this.ee.on(_sessionEntity.SESSION_EVENTS.UPDATE, (eventType, sessionState) => {
+    this.ee.on(_constants2.SESSION_EVENTS.UPDATE, (eventType, sessionState) => {
       // this will only have an effect if ST is NOT already in full mode
-      if (sessionState.sessionReplayMode === _sessionEntity.MODE.FULL) switchToFull();
+      if (sessionState.sessionReplayMode === _constants2.MODE.FULL) switchToFull();
     });
 
     /**
@@ -102,21 +102,21 @@ class Aggregate extends _aggregateBase.AggregateBase {
      * "external" input in this case means errors thrown on the page or session replay itself being triggered to run in full mode by the API, which updates the session entity.
      */
     const switchToFull = () => {
-      if (this.agentRuntime?.session?.state?.sessionReplayMode !== _sessionEntity.MODE.FULL) return;
-      if (mostRecentModeKnown !== _sessionEntity.MODE.FULL) {
+      if (this.agentRuntime?.session?.state?.sessionReplayMode !== _constants2.MODE.FULL) return;
+      if (mostRecentModeKnown !== _constants2.MODE.FULL) {
         const prevMode = mostRecentModeKnown;
-        mostRecentModeKnown = _sessionEntity.MODE.FULL;
+        mostRecentModeKnown = _constants2.MODE.FULL;
         sessionEntity.write({
           sessionTraceMode: mostRecentModeKnown
         });
         this.isStandalone = false;
-        if (prevMode === _sessionEntity.MODE.ERROR && this.#scheduler) {
+        if (prevMode === _constants2.MODE.ERROR && this.#scheduler) {
           this.trimSTNs(ERROR_MODE_SECONDS_WINDOW); // up until now, Trace would've been just buffering nodes up to max, which needs to be trimmed to last X seconds
           this.#scheduler.runHarvest({
             needResponse: true
           });
         } else {
-          controlTraceOp(_sessionEntity.MODE.FULL);
+          controlTraceOp(_constants2.MODE.FULL);
         }
       }
     };
@@ -130,11 +130,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
         switchToFull();
       }, this.featureName, this.ee);
       const stopTracePerm = () => {
-        if (sessionEntity.state.sessionTraceMode !== _sessionEntity.MODE.OFF) sessionEntity.write({
-          sessionTraceMode: _sessionEntity.MODE.OFF
+        if (sessionEntity.state.sessionTraceMode !== _constants2.MODE.OFF) sessionEntity.write({
+          sessionTraceMode: _constants2.MODE.OFF
         });
         operationalGate.permanentlyDecide(false);
-        if (mostRecentModeKnown === _sessionEntity.MODE.FULL) this.#scheduler?.runHarvest(); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
+        if (mostRecentModeKnown === _constants2.MODE.FULL) this.#scheduler?.runHarvest(); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
         this.#scheduler?.stopTimer(true); // the 'true' arg here will forcibly block any future call to runHarvest, so the last runHarvest above must be prior
         this.#scheduler = null;
       };
@@ -151,33 +151,33 @@ class Aggregate extends _aggregateBase.AggregateBase {
           /* Assuming on page visible that the trace mode is updated from shared session,
            - if trace is turned off from the other page, it should be likewise here.
            - if trace switches to Full mode, harvest should start (prev: Error) if not already running (prev: Full). */
-          this.ee.on(_sessionEntity.SESSION_EVENTS.RESUME, () => {
+          this.ee.on(_constants2.SESSION_EVENTS.RESUME, () => {
             const updatedTraceMode = sessionEntity.state.sessionTraceMode;
-            if (updatedTraceMode === _sessionEntity.MODE.OFF) stopTracePerm();else if (updatedTraceMode === _sessionEntity.MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({
+            if (updatedTraceMode === _constants2.MODE.OFF) stopTracePerm();else if (updatedTraceMode === _constants2.MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({
               needResponse: true
             });
             mostRecentModeKnown = updatedTraceMode;
           });
-          this.ee.on(_sessionEntity.SESSION_EVENTS.PAUSE, () => {
+          this.ee.on(_constants2.SESSION_EVENTS.PAUSE, () => {
             mostRecentModeKnown = sessionEntity.state.sessionTraceMode;
           });
           if (!sessionEntity.isNew) {
             // inherit the same mode as existing session's Trace
-            if (sessionEntity.state.sessionReplayMode === _sessionEntity.MODE.OFF) this.isStandalone = true;
+            if (sessionEntity.state.sessionReplayMode === _constants2.MODE.OFF) this.isStandalone = true;
             controlTraceOp(mostRecentModeKnown = sessionEntity.state.sessionTraceMode);
           } else {
             // for new sessions, see the truth table associated with NEWRELIC-8662 wrt the new Trace behavior under session management
             const replayMode = await (0, _replayMode.getSessionReplayMode)(agentIdentifier);
-            if (replayMode === _sessionEntity.MODE.OFF) this.isStandalone = true; // without SR, Traces are still subject to old harvest limits
+            if (replayMode === _constants2.MODE.OFF) this.isStandalone = true; // without SR, Traces are still subject to old harvest limits
 
             let startingMode;
             if (traceOn === true) {
               // CASE: both trace (entitlement+sampling) & replay (entitlement) flags are true from RUM
-              startingMode = _sessionEntity.MODE.FULL; // always full capture regardless of replay sampling decisions
+              startingMode = _constants2.MODE.FULL; // always full capture regardless of replay sampling decisions
             } else {
               // CASE: trace flag is off, BUT it must still run if replay is on (possibly)
               // At this point, it's possible that 1 or more exception was thrown, in which case just start in full if Replay originally started in ERROR mode.
-              if (replayMode === _sessionEntity.MODE.ERROR && seenAnError) startingMode = _sessionEntity.MODE.FULL;else startingMode = replayMode;
+              if (replayMode === _constants2.MODE.ERROR && seenAnError) startingMode = _constants2.MODE.FULL;else startingMode = replayMode;
             }
             sessionEntity.write({
               sessionTraceMode: mostRecentModeKnown = startingMode
@@ -251,7 +251,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }); // sends first stn harvest immediately
     startupBuffer.decide(true); // signal to ALLOW & process data in EE's buffer into internal nodes queued for next harvest
   }
-
   #onHarvestFinished(result) {
     if (result.sent && result.responseText && !this.ptid) {
       // continue interval harvest only if ptid was returned by server on the first
@@ -287,10 +286,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
       const currentMode = this.agentRuntime.session.state.sessionTraceMode;
       /* There could still be nodes previously collected even after Trace (w/ session mgmt) is turned off. Hence, continue to send the last batch.
        * The intermediary controller SHOULD be already switched off so that no nodes are further queued. */
-      if (currentMode === _sessionEntity.MODE.OFF && Object.keys(this.trace).length === 0) return;
-      if (currentMode === _sessionEntity.MODE.ERROR) return; // Trace in this mode should never be harvesting, even on unload
+      if (currentMode === _constants2.MODE.OFF && Object.keys(this.trace).length === 0) return;
+      if (currentMode === _constants2.MODE.ERROR) return; // Trace in this mode should never be harvesting, even on unload
     }
-
     return this.takeSTNs(options.retry);
   }
 
@@ -464,7 +462,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
   storeSTN(stn) {
     if (this.nodeCount >= this.maxNodesPerHarvest) {
       // limit the amount of pending data awaiting next harvest
-      if (this.isStandalone || this.agentRuntime.session.state.sessionTraceMode !== _sessionEntity.MODE.ERROR) return;
+      if (this.isStandalone || this.agentRuntime.session.state.sessionTraceMode !== _constants2.MODE.ERROR) return;
       const openedSpace = this.trimSTNs(ERROR_MODE_SECONDS_WINDOW); // but maybe we could make some space by discarding irrelevant nodes if we're in sessioned Error mode
       if (openedSpace === 0) return;
     }

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

@@ -5,19 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.START = exports.RESOURCE = exports.PUSH_STATE = exports.FN_START = exports.FN_END = exports.FEATURE_NAME = exports.END = exports.BST_RESOURCE = void 0;
 var _features = require("../../loaders/features/features");
-const FEATURE_NAME = _features.FEATURE_NAMES.sessionTrace;
-exports.FEATURE_NAME = FEATURE_NAME;
-const BST_RESOURCE = 'bstResource';
-exports.BST_RESOURCE = BST_RESOURCE;
-const RESOURCE = 'resource';
-exports.RESOURCE = RESOURCE;
-const START = '-start';
-exports.START = START;
-const END = '-end';
-exports.END = END;
-const FN_START = 'fn' + START;
-exports.FN_START = FN_START;
-const FN_END = 'fn' + END;
-exports.FN_END = FN_END;
-const PUSH_STATE = 'pushState';
-exports.PUSH_STATE = PUSH_STATE;
+const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.sessionTrace;
+const BST_RESOURCE = exports.BST_RESOURCE = 'bstResource';
+const RESOURCE = exports.RESOURCE = 'resource';
+const START = exports.START = '-start';
+const END = exports.END = '-end';
+const FN_START = exports.FN_START = 'fn' + START;
+const FN_END = exports.FN_END = 'fn' + END;
+const PUSH_STATE = exports.PUSH_STATE = 'pushState';