@newrelic/browser-agent 1.233.1 → 1.235.0

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

@@ -6,13 +6,14 @@ Object.defineProperty(exports, "__esModule", {
 exports.Aggregate = void 0;
 var _registerHandler = require("../../../common/event-emitter/register-handler");
 var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
-var _stringify = require("../../../common/util/stringify");
 var _parseUrl = require("../../../common/url/parse-url");
 var _config = require("../../../common/config/config");
 var _now = require("../../../common/timing/now");
 var _constants = require("../constants");
 var _drain = require("../../../common/drain/drain");
 var _handlerCache = require("../../utils/handler-cache");
+var _sessionEntity = require("../../../common/session/session-entity");
+var _replayMode = require("../../session_replay/replay-mode");
 var _aggregateBase = require("../../utils/aggregate-base");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
@@ -41,16 +42,21 @@ const toAggregate = {
   mousing: [1000, 2000],
   touching: [1000, 2000]
 };
-const MAX_TRACE_DURATION = 15 * 60 * 1000; // 15 minutes
+const MAX_TRACE_DURATION = 10 * 60 * 1000; // 10 minutes
+const REQ_THRESHOLD_TO_SEND = 30;
+const ERROR_MODE_SECONDS_WINDOW = 30 * 1000; // sliding window of nodes to track when simply monitoring (but not harvesting) in error mode
 
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
+  #scheduler;
   constructor(agentIdentifier, aggregator, argsObj) {
     var _this;
-    // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
     _this = this;
-    if (!(0, _config.getRuntime)(agentIdentifier).xhrWrappable) return;
+    this.agentRuntime = (0, _config.getRuntime)(agentIdentifier);
+
+    // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
+    if (!this.agentRuntime.xhrWrappable) return;
     this.resourceObserver = argsObj?.resourceObserver; // undefined if observer couldn't be created
     this.ptid = '';
     this.trace = {};
@@ -58,105 +64,217 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.sentTrace = null;
     this.harvestTimeSeconds = (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10;
     this.maxNodesPerHarvest = (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000;
-    this.laststart = 0;
-    const handlerCache = new _handlerCache.HandlerCache();
-    (0, _registerHandler.registerHandler)('feat-stn', () => {
-      if (typeof PerformanceNavigationTiming !== 'undefined') {
-        this.storeTiming(window.performance.getEntriesByType('navigation')[0]);
-      } else {
-        this.storeTiming(window.performance.timing);
+    this.isStandalone = false;
+    const operationalGate = new _handlerCache.HandlerCache(); // acts as a controller-intermediary that can enable or disable this feature's collection dynamically
+    const sessionEntity = this.agentRuntime.session;
+
+    /* --- The following section deals with user sessions concept & contains non-trivial control flow. --- */
+    const controlTraceOp = traceMode => {
+      switch (traceMode) {
+        case _sessionEntity.MODE.ERROR:
+          this.startTracing(operationalGate, true);
+          break;
+        case _sessionEntity.MODE.FULL:
+        case true:
+          this.startTracing(operationalGate);
+          break;
+        case _sessionEntity.MODE.OFF:
+        case false:
+        default:
+          // this feature becomes "off" (does nothing & nothing is sent)
+          operationalGate.decide(false);
+          break;
       }
-      const scheduler = new _harvestScheduler.HarvestScheduler('resources', {
-        onFinished: onHarvestFinished.bind(this),
-        retryDelay: this.harvestTimeSeconds
-      }, this);
-      scheduler.harvest.on('resources', prepareHarvest.bind(this));
-      scheduler.runHarvest({
-        needResponse: true
-      }); // sends first stn harvest immediately
-      handlerCache.decide(true);
-      function onHarvestFinished(result) {
-        if (result.sent && result.responseText && !this.ptid) {
-          // continue interval harvest only if ptid was returned by server on the first
-          (0, _config.getRuntime)(this.agentIdentifier).ptid = this.ptid = result.responseText;
-          scheduler.startTimer(this.harvestTimeSeconds);
+    };
+    if (!sessionEntity) {
+      // Since session manager isn't around, do the old Trace behavior of waiting for RUM response to decide feature activation.
+      this.isStandalone = true;
+      (0, _registerHandler.registerHandler)('rumresp-stn', on => controlTraceOp(on), this.featureName, this.ee);
+    } else {
+      let seenAnError = false;
+      let mostRecentModeKnown;
+      (0, _registerHandler.registerHandler)('errorAgg', () => {
+        // Switch to full capture mode on next harvest on first exception thrown only. Only done once so that sessionTraceMode isn't constantly overwritten after decision block.
+        if (!seenAnError) {
+          seenAnError = true;
+          /* If this cb executes before Trace has started, then no further action needed. But if...
+           - startTracing already ran under ERROR mode, then it will NOT have kicked off the harvest-scheduler so that needs to be done & switch mode.
+           - startTracing never ran because mode is OFF or Replay aborted or Traced turned off elsewhere OR trace already in FULL, then this should do nothing. */
+          if (sessionEntity.state.sessionTraceMode === _sessionEntity.MODE.ERROR && this.#scheduler) {
+            sessionEntity.write({
+              sessionTraceMode: mostRecentModeKnown = _sessionEntity.MODE.FULL
+            });
+            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
+            });
+          }
         }
-        if (result.sent && result.retry && this.sentTrace) {
-          // merge previous trace back into buffer to retry for next harvest
-          Object.entries(this.sentTrace).forEach(_ref => {
-            let [name, listOfSTNodes] = _ref;
-            if (this.nodeCount >= this.maxNodesPerHarvest) return;
-            this.nodeCount += listOfSTNodes.length;
-            this.trace[name] = this.trace[name] ? listOfSTNodes.concat(this.trace[name]) : listOfSTNodes;
+      }, this.featureName, this.ee);
+      const stopTracePerm = () => {
+        if (sessionEntity.state.sessionTraceMode !== _sessionEntity.MODE.OFF) sessionEntity.write({
+          sessionTraceMode: _sessionEntity.MODE.OFF
+        });
+        operationalGate.permanentlyDecide(false);
+        this.#scheduler?.stopTimer(true);
+        if (mostRecentModeKnown === _sessionEntity.MODE.FULL) this.#scheduler?.runHarvest(); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
+        this.#scheduler = null;
+      };
+
+      // CAUTION: everything inside this promise runs post-load; event subscribers must be pre-load aka synchronous with constructor
+      this.waitForFlags(['stn', 'sr']).then(async _ref => {
+        let [traceOn, replayOn] = _ref;
+        if (!replayOn) {
+          // When sr = 0 from BCS, also do the old Trace behavior:
+          this.isStandalone = true;
+          controlTraceOp(traceOn);
+        } else {
+          this.ee.on('REPLAY_ABORTED', () => stopTracePerm());
+          /* 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, () => {
+            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({
+              needResponse: true
+            });
+            mostRecentModeKnown = updatedTraceMode;
           });
-          this.sentTrace = null;
-        }
-      }
-      function prepareHarvest(options) {
-        if ((0, _now.now)() > MAX_TRACE_DURATION) {
-          // been collecting for over 15 min, empty trace object and bail
-          scheduler.stopTimer();
-          this.trace = {};
-          return;
+          this.ee.on(_sessionEntity.SESSION_EVENTS.PAUSE, () => mostRecentModeKnown = sessionEntity.state.sessionTraceMode);
+          if (!sessionEntity.isNew) {
+            // inherit the same mode as existing session's Trace
+            const existingTraceMode = mostRecentModeKnown = sessionEntity.state.sessionTraceMode;
+            if (existingTraceMode === _sessionEntity.MODE.OFF) this.isStandalone = true;
+            controlTraceOp(existingTraceMode);
+          } 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
+
+            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
+            } 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;
+            }
+            sessionEntity.write({
+              sessionTraceMode: mostRecentModeKnown = startingMode
+            });
+            controlTraceOp(startingMode);
+          }
         }
-        // Only harvest when there are more than 30 nodes to send after the very first.
-        if (this.ptid && this.nodeCount <= 30) return;
-        return this.takeSTNs(options.retry);
-      }
-    }, this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('block-stn', () => handlerCache.decide(false), this.featureName, this.ee);
+      });
+    }
+    /* --- EoS --- */
 
     // register the handlers immediately... but let the handlerCache decide if the data should actually get stored...
     (0, _registerHandler.registerHandler)('bst', function () {
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
-      return handlerCache.settle(() => _this.storeEvent(...args));
+      return operationalGate.settle(() => _this.storeEvent(...args));
     }, this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('bstTimer', function () {
+    (0, _registerHandler.registerHandler)('bstResource', function () {
       for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
         args[_key2] = arguments[_key2];
       }
-      return handlerCache.settle(() => _this.storeTimer(...args));
+      return operationalGate.settle(() => _this.storeResources(...args));
     }, this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('bstResource', function () {
+    (0, _registerHandler.registerHandler)('bstHist', function () {
       for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
         args[_key3] = arguments[_key3];
       }
-      return handlerCache.settle(() => _this.storeResources(...args));
+      return operationalGate.settle(() => _this.storeHist(...args));
     }, this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('bstHist', function () {
+    (0, _registerHandler.registerHandler)('bstXhrAgg', function () {
       for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
         args[_key4] = arguments[_key4];
       }
-      return handlerCache.settle(() => _this.storeHist(...args));
+      return operationalGate.settle(() => _this.storeXhrAgg(...args));
     }, this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('bstXhrAgg', function () {
+    (0, _registerHandler.registerHandler)('bstApi', function () {
       for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
         args[_key5] = arguments[_key5];
       }
-      return handlerCache.settle(() => _this.storeXhrAgg(...args));
+      return operationalGate.settle(() => _this.storeSTN(...args));
     }, this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('bstApi', function () {
+    (0, _registerHandler.registerHandler)('errorAgg', function () {
       for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
         args[_key6] = arguments[_key6];
       }
-      return handlerCache.settle(() => _this.storeSTN(...args));
+      return operationalGate.settle(() => _this.storeErrorAgg(...args));
     }, this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('errorAgg', function () {
+    (0, _registerHandler.registerHandler)('pvtAdded', function () {
       for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
         args[_key7] = arguments[_key7];
       }
-      return handlerCache.settle(() => _this.storeErrorAgg(...args));
-    }, this.featureName, this.ee);
-    (0, _registerHandler.registerHandler)('pvtAdded', function () {
-      for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
-        args[_key8] = arguments[_key8];
-      }
-      return handlerCache.settle(() => _this.processPVT(...args));
+      return operationalGate.settle(() => _this.processPVT(...args));
     }, this.featureName, this.ee);
     (0, _drain.drain)(this.agentIdentifier, this.featureName);
   }
+  startTracing(startupBuffer) {
+    let dontStartHarvestYet = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (typeof PerformanceNavigationTiming !== 'undefined') {
+      this.storeTiming(window.performance.getEntriesByType('navigation')[0]);
+    } else {
+      this.storeTiming(window.performance.timing);
+    }
+    this.#scheduler = new _harvestScheduler.HarvestScheduler('resources', {
+      onFinished: this.#onHarvestFinished.bind(this),
+      retryDelay: this.harvestTimeSeconds
+    }, this);
+    this.#scheduler.harvest.on('resources', this.#prepareHarvest.bind(this));
+    if (dontStartHarvestYet === false) this.#scheduler.runHarvest({
+      needResponse: true
+    }); // 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
+      this.agentRuntime.ptid = this.ptid = result.responseText;
+      this.#scheduler.startTimer(this.harvestTimeSeconds);
+    }
+    if (result.sent && result.retry && this.sentTrace) {
+      // merge previous trace back into buffer to retry for next harvest
+      Object.entries(this.sentTrace).forEach(_ref2 => {
+        let [name, listOfSTNodes] = _ref2;
+        if (this.nodeCount >= this.maxNodesPerHarvest) return;
+        this.nodeCount += listOfSTNodes.length;
+        this.trace[name] = this.trace[name] ? listOfSTNodes.concat(this.trace[name]) : listOfSTNodes;
+      });
+      this.sentTrace = null;
+    }
+  }
+  #prepareHarvest(options) {
+    /* Standalone refers to the legacy version of ST before the idea of 'session' or the Replay feature existed.
+      It has a different behavior on returning a payload for harvest than when used in tandem with either of those concepts. */
+    if (this.isStandalone) {
+      if ((0, _now.now)() > MAX_TRACE_DURATION) {
+        // been collecting for over the longest duration we should run for, empty trace object so ST has nothing to send
+        this.#scheduler.stopTimer();
+        this.trace = {};
+        return;
+      }
+      // Only harvest when more than some threshold of nodes are pending, after the very first harvest.
+      if (this.ptid && this.nodeCount <= REQ_THRESHOLD_TO_SEND) return;
+    } else {
+      //   -- *cli May '26 - Update: Not rate limiting backgrounded pages either for now.
+      //   if (this.ptid && document.visibilityState === 'hidden' && this.nodeCount <= REQ_THRESHOLD_TO_SEND) return
+
+      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
+    }
+
+    return this.takeSTNs(options.retry);
+  }
 
   // PageViewTiming (FEATURE) events and metrics, such as 'load', 'lcp', etc. pipes into ST here.
   processPVT(name, value, attrs) {
@@ -198,18 +316,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
   }
 
-  // Tracks duration of native APIs wrapped by wrap-timer & wrap-raf.
-  storeTimer(target, start, end, type) {
-    const evt = {
-      n: type,
-      s: start,
-      e: end,
-      o: 'window',
-      t: type === 'requestAnimationFrame' ? type : 'timer'
-    };
-    this.storeSTN(evt);
-  }
-
   // Tracks the events and their listener's duration on objects wrapped by wrap-events.
   storeEvent(currentEvent, target, start, end) {
     if (this.shouldIgnoreEvent(currentEvent, target)) return;
@@ -290,12 +396,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
     };
     this.storeSTN(node);
   }
-
+  #laststart = 0;
   // Processes all the PerformanceResourceTiming entries captured (by observer).
   storeResources(resources) {
     if (!resources || resources.length === 0) return;
     resources.forEach(currentResource => {
-      if ((currentResource.fetchStart | 0) <= this.laststart) return; // don't recollect already-seen resources
+      if ((currentResource.fetchStart | 0) <= this.#laststart) return; // don't recollect already-seen resources
 
       const parsed = (0, _parseUrl.parseUrl)(currentResource.name);
       const res = {
@@ -308,7 +414,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       };
       this.storeSTN(res);
     });
-    this.laststart = resources[resources.length - 1].fetchStart | 0;
+    this.#laststart = resources[resources.length - 1].fetchStart | 0;
   }
 
   // JavascriptError (FEATURE) events pipes into ST here.
@@ -339,20 +445,50 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
   // Central function called by all the other store__ & addToTrace API to append a trace node.
   storeSTN(stn) {
-    if (this.nodeCount >= this.maxNodesPerHarvest) return; // limit the amount of data that is stored at once
-
+    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;
+      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;
+    }
     if (this.trace[stn.n]) this.trace[stn.n].push(stn);else this.trace[stn.n] = [stn];
     this.nodeCount++;
   }
 
+  /**
+   * Trim the collection of nodes awaiting harvest such that those seen outside a certain span of time are discarded.
+   * @param {number} lookbackDuration Past length of time until now for which we care about nodes, in milliseconds
+   * @returns {number} However many nodes were discarded after trimming.
+   */
+  trimSTNs(lookbackDuration) {
+    let prunedNodes = 0;
+    const cutoffHighResTime = Math.max((0, _now.now)() - lookbackDuration, 0);
+    Object.keys(this.trace).forEach(nameCategory => {
+      const nodeList = this.trace[nameCategory];
+      /* Notice nodes are appending under their name's list as they end and are stored. This means each list is already (roughly) sorted in chronological order by end time.
+       * This isn't exact since nodes go through some processing & EE handlers chain, but it's close enough as we still capture nodes whose duration overlaps the lookback window.
+       * ASSUMPTION: all 'end' timings stored are relative to timeOrigin (DOMHighResTimeStamp) and not Unix epoch based. */
+      let cutoffIdx = nodeList.findIndex(node => cutoffHighResTime <= node.e);
+      if (cutoffIdx == 0) return;else if (cutoffIdx < 0) {
+        // whole list falls outside lookback window and is irrelevant
+        cutoffIdx = nodeList.length;
+        delete this.trace[nameCategory];
+      } else nodeList.splice(0, cutoffIdx); // chop off everything outside our window i.e. before the last <lookbackDuration> timeframe
+
+      this.nodeCount -= cutoffIdx;
+      prunedNodes += cutoffIdx;
+    });
+    return prunedNodes;
+  }
+
   // Used by session trace's harvester to create the payload body.
   takeSTNs(retry) {
     if (!this.resourceObserver) {
       // if PO isn't supported, this checks resourcetiming buffer every harvest.
       this.storeResources(window.performance.getEntriesByType('resource'));
     }
-    const stns = Object.entries(this.trace).flatMap(_ref2 => {
-      let [name, listOfSTNodes] = _ref2;
+    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
       if (!(name in toAggregate)) return listOfSTNodes;
       // Special processing for event nodes dealing with user inputs:
@@ -366,7 +502,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     this.trace = {};
     this.nodeCount = 0;
-    const stnInfo = {
+    return {
       qs: {
         st: String((0, _config.getRuntime)(this.agentIdentifier).offset)
       },
@@ -374,19 +510,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
         res: stns
       }
     };
-    if (!this.ptid) {
-      // send custom and user attributes on the very first ST harvest only
-      const {
-        userAttributes,
-        atts,
-        jsAttributes
-      } = (0, _config.getInfo)(this.agentIdentifier);
-      stnInfo.qs.ua = userAttributes;
-      stnInfo.qs.at = atts;
-      const ja = (0, _stringify.stringify)(jsAttributes);
-      stnInfo.qs.ja = ja === '{}' ? null : ja;
-    }
-    return stnInfo;
   }
   smearEvtsByOrigin(name) {
     const maxGap = toAggregate[name][0];

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.START = exports.RESOURCE = exports.PUSH_STATE = exports.FN_START = exports.FN_END = exports.FEATURE_NAME = exports.END = exports.BST_TIMER = exports.BST_RESOURCE = void 0;
+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;
@@ -19,7 +19,5 @@ const FN_START = 'fn' + START;
 exports.FN_START = FN_START;
 const FN_END = 'fn' + END;
 exports.FN_END = FN_END;
-const BST_TIMER = 'bstTimer';
-exports.BST_TIMER = BST_TIMER;
 const PUSH_STATE = 'pushState';
 exports.PUSH_STATE = PUSH_STATE;

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

@@ -21,7 +21,6 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 const {
   BST_RESOURCE,
   RESOURCE,
-  BST_TIMER,
   START,
   END,
   FEATURE_NAME,
@@ -37,8 +36,6 @@ class Instrument extends _instrumentBase.InstrumentBase {
     if (!_globalScope.isBrowserScope) return; // session traces not supported outside web env
 
     const thisInstrumentEE = this.ee;
-    this.timerEE = (0, _wrap.wrapTimer)(thisInstrumentEE);
-    this.rafEE = (0, _wrap.wrapRaf)(thisInstrumentEE);
     (0, _wrap.wrapHistory)(thisInstrumentEE);
     this.eventsEE = (0, _wrap.wrapEvents)(thisInstrumentEE);
     this.eventsEE.on(FN_START, function (args, target) {
@@ -49,19 +46,6 @@ class Instrument extends _instrumentBase.InstrumentBase {
       // When ajax is disabled, this may fail without making ajax a dependency of session_trace
       (0, _handle.handle)('bst', [args[0], target, this.bstStart, (0, _now.now)()], undefined, _features.FEATURE_NAMES.sessionTrace, thisInstrumentEE);
     });
-    this.timerEE.on(FN_START, function (args, obj, type) {
-      this.bstStart = (0, _now.now)();
-      this.bstType = type;
-    });
-    this.timerEE.on(FN_END, function (args, target) {
-      (0, _handle.handle)(BST_TIMER, [target, this.bstStart, (0, _now.now)(), this.bstType], undefined, _features.FEATURE_NAMES.sessionTrace, thisInstrumentEE);
-    });
-    this.rafEE.on(FN_START, function () {
-      this.bstStart = (0, _now.now)();
-    });
-    this.rafEE.on(FN_END, function (args, target) {
-      (0, _handle.handle)(BST_TIMER, [target, this.bstStart, (0, _now.now)(), 'requestAnimationFrame'], undefined, _features.FEATURE_NAMES.sessionTrace, thisInstrumentEE);
-    });
     thisInstrumentEE.on(PUSH_STATE + START, function (args) {
       this.time = (0, _now.now)();
       this.startPath = location.pathname + location.hash;

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

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.originalSetTimeout = exports.START = exports.SPA_NODE = exports.REMAINING = exports.MAX_TIMER_BUDGET = exports.JS_TIME = exports.JSONP_NODE = exports.JSONP_END = exports.INTERACTION_EVENTS = exports.INTERACTION_API = exports.INTERACTION = exports.FN_START = exports.FN_END = exports.FETCH_START = exports.FETCH_DONE = exports.FETCH_BODY = exports.FETCH = exports.FEATURE_NAME = exports.END = exports.CB_START = exports.CB_END = exports.BODY = void 0;
 var _config = require("../../common/config/config");
-var _globalScope = require("../../common/util/global-scope");
 var _features = require("../../loaders/features/features");
 const FEATURE_NAME = _features.FEATURE_NAMES.spa;
 exports.FEATURE_NAME = FEATURE_NAME;

package/dist/cjs/features/utils/agent-session.js

@@ -8,7 +8,6 @@ var _config = require("../../common/config/config");
 var _drain = require("../../common/drain/drain");
 var _contextualEe = require("../../common/event-emitter/contextual-ee");
 var _registerHandler = require("../../common/event-emitter/register-handler");
-var _globalScope = require("../../common/util/global-scope");
 var _sessionEntity = require("../../common/session/session-entity");
 var _localStorage = require("../../common/storage/local-storage.js");
 var _firstPartyCookies = require("../../common/storage/first-party-cookies");
@@ -16,43 +15,28 @@ let ranOnce = 0;
 function setupAgentSession(agentIdentifier) {
   const agentRuntime = (0, _config.getRuntime)(agentIdentifier);
   if (ranOnce++) return agentRuntime.session;
-  const sharedEE = _contextualEe.ee.get(agentIdentifier);
+  const sessionInit = (0, _config.getConfiguration)(agentIdentifier).session;
+  /* Domain is a string that can be specified by customer. The only way to keep the session object across subdomains is using first party cookies.
+    This determines which storage wrapper the session manager will use to keep state. */
+  const storageTypeInst = sessionInit?.domain ? new _firstPartyCookies.FirstPartyCookies(sessionInit.domain) : new _localStorage.LocalStorage();
+  agentRuntime.session = new _sessionEntity.SessionEntity({
+    agentIdentifier,
+    key: 'SESSION',
+    storage: storageTypeInst,
+    expiresMs: sessionInit?.expiresMs,
+    inactiveMs: sessionInit?.inactiveMs
+  });
 
-  // domain is a string that can be specified by customer.
-  // only way to keep the session object across subdomains is using first party cookies
-  // This determines which storage wrapper the session manager will use to keep state
-  let storageAPI;
-  const cookiesEnabled = (0, _config.getConfigurationValue)(agentIdentifier, 'privacy.cookies_enabled') === true;
-  if (cookiesEnabled && _globalScope.isBrowserScope) {
-    storageAPI = (0, _config.getConfigurationValue)(agentIdentifier, 'session.domain') ? new _firstPartyCookies.FirstPartyCookies((0, _config.getConfigurationValue)(agentIdentifier, 'session.domain')) : new _localStorage.LocalStorage();
-  }
-  if (cookiesEnabled) {
-    // defaults to "LocalMemory" if storageAPI is undefined, such as in Worker build
-    agentRuntime.session = new _sessionEntity.SessionEntity({
-      agentIdentifier,
-      key: 'SESSION',
-      storageAPI,
-      expiresMs: (0, _config.getConfigurationValue)(agentIdentifier, 'session.expiresMs'),
-      inactiveMs: (0, _config.getConfigurationValue)(agentIdentifier, 'session.inactiveMs')
-    });
-  }
-
-  // The first time the agent runs on a page, it should put everything
-  // that's currently stored in the storage API into the local info.jsAttributes object
-  if (_globalScope.isBrowserScope) {
-    // retrieve & re-add all of the persisted setCustomAttribute|setUserId k-v from previous page load(s)
-    const customSessionData = agentRuntime.session.state.custom;
-    const agentInfo = (0, _config.getInfo)(agentIdentifier);
-    if (customSessionData) {
-      (0, _config.setInfo)(agentIdentifier, {
-        ...agentInfo,
-        jsAttributes: {
-          ...agentInfo.jsAttributes,
-          ...customSessionData
-        }
-      });
-    }
+  // Retrieve & re-add all of the persisted setCustomAttribute|setUserId k-v from previous page load(s), if any was stored.
+  const customSessionData = agentRuntime.session.state.custom;
+  const agentInfo = (0, _config.getInfo)(agentIdentifier);
+  if (customSessionData) {
+    agentInfo.jsAttributes = {
+      ...agentInfo.jsAttributes,
+      ...customSessionData
+    };
   }
+  const sharedEE = _contextualEe.ee.get(agentIdentifier);
 
   // any calls to newrelic.setCustomAttribute(<persisted>) will need to be added to:
   // local info.jsAttributes {}