@newrelic/browser-agent 1.234.0 → 1.236.0

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

@@ -4,13 +4,14 @@
  */
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
-import { stringify } from '../../../common/util/stringify';
 import { parseUrl } from '../../../common/url/parse-url';
-import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
+import { getConfigurationValue, getRuntime } from '../../../common/config/config';
 import { now } from '../../../common/timing/now';
 import { FEATURE_NAME } from '../constants';
 import { drain } from '../../../common/drain/drain';
 import { HandlerCache } from '../../utils/handler-cache';
+import { MODE, SESSION_EVENTS } from '../../../common/session/session-entity';
+import { getSessionReplayMode } from '../../session_replay/replay-mode';
 import { AggregateBase } from '../../utils/aggregate-base';
 const ignoredEvents = {
   // we find that certain events make the data too noisy to be useful
@@ -34,16 +35,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
 
 export class Aggregate extends AggregateBase {
   static featureName = 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, FEATURE_NAME);
     _this = this;
-    if (!getRuntime(agentIdentifier).xhrWrappable) return;
+    this.agentRuntime = 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 = {};
@@ -51,105 +57,217 @@ export class Aggregate extends AggregateBase {
     this.sentTrace = null;
     this.harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10;
     this.maxNodesPerHarvest = getConfigurationValue(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000;
-    this.laststart = 0;
-    const handlerCache = new HandlerCache();
-    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(); // 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 MODE.ERROR:
+          this.startTracing(operationalGate, true);
+          break;
+        case MODE.FULL:
+        case true:
+          this.startTracing(operationalGate);
+          break;
+        case MODE.OFF:
+        case false:
+        default:
+          // this feature becomes "off" (does nothing & nothing is sent)
+          operationalGate.decide(false);
+          break;
       }
-      const scheduler = new 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
-          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;
+      registerHandler('rumresp-stn', on => controlTraceOp(on), this.featureName, this.ee);
+    } else {
+      let seenAnError = false;
+      let mostRecentModeKnown;
+      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 === MODE.ERROR && this.#scheduler) {
+            sessionEntity.write({
+              sessionTraceMode: mostRecentModeKnown = 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 !== MODE.OFF) sessionEntity.write({
+          sessionTraceMode: MODE.OFF
+        });
+        operationalGate.permanentlyDecide(false);
+        this.#scheduler?.stopTimer(true);
+        if (mostRecentModeKnown === 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(SESSION_EVENTS.RESUME, () => {
+            const updatedTraceMode = sessionEntity.state.sessionTraceMode;
+            if (updatedTraceMode === MODE.OFF) stopTracePerm();else if (updatedTraceMode === MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({
+              needResponse: true
+            });
+            mostRecentModeKnown = updatedTraceMode;
           });
-          this.sentTrace = null;
-        }
-      }
-      function prepareHarvest(options) {
-        if (now() > MAX_TRACE_DURATION) {
-          // been collecting for over 15 min, empty trace object and bail
-          scheduler.stopTimer();
-          this.trace = {};
-          return;
+          this.ee.on(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 === 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 getSessionReplayMode(agentIdentifier);
+            if (replayMode === 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 = 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 === MODE.ERROR && seenAnError) startingMode = 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);
-    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...
     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);
-    registerHandler('bstTimer', function () {
+    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);
-    registerHandler('bstResource', function () {
+    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);
-    registerHandler('bstHist', function () {
+    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);
-    registerHandler('bstXhrAgg', function () {
+    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);
-    registerHandler('bstApi', function () {
+    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);
-    registerHandler('errorAgg', function () {
+    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);
-    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);
     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('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 (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 === MODE.OFF && Object.keys(this.trace).length === 0) return;
+      if (currentMode === 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) {
@@ -191,18 +309,6 @@ export class Aggregate extends 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;
@@ -283,12 +389,12 @@ export class Aggregate extends 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 = parseUrl(currentResource.name);
       const res = {
@@ -301,7 +407,7 @@ export class Aggregate extends 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.
@@ -332,20 +438,50 @@ export class Aggregate extends 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 !== 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(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:
@@ -359,7 +495,7 @@ export class Aggregate extends AggregateBase {
     }
     this.trace = {};
     this.nodeCount = 0;
-    const stnInfo = {
+    return {
       qs: {
         st: String(getRuntime(this.agentIdentifier).offset)
       },
@@ -367,19 +503,6 @@ export class Aggregate extends AggregateBase {
         res: stns
       }
     };
-    if (!this.ptid) {
-      // send custom and user attributes on the very first ST harvest only
-      const {
-        userAttributes,
-        atts,
-        jsAttributes
-      } = getInfo(this.agentIdentifier);
-      stnInfo.qs.ua = userAttributes;
-      stnInfo.qs.at = atts;
-      const ja = stringify(jsAttributes);
-      stnInfo.qs.ja = ja === '{}' ? null : ja;
-    }
-    return stnInfo;
   }
   smearEvtsByOrigin(name) {
     const maxGap = toAggregate[name][0];

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

@@ -6,5 +6,4 @@ export const START = '-start';
 export const END = '-end';
 export const FN_START = 'fn' + START;
 export const FN_END = 'fn' + END;
-export const BST_TIMER = 'bstTimer';
 export const PUSH_STATE = 'pushState';

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

@@ -3,16 +3,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { handle } from '../../../common/event-emitter/handle';
-import { wrapHistory, wrapEvents, wrapTimer, wrapRaf } from '../../../common/wrap';
+import { wrapHistory, wrapEvents } from '../../../common/wrap';
 import { now } from '../../../common/timing/now';
 import { InstrumentBase } from '../../utils/instrument-base';
 import * as CONSTANTS from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { isBrowserScope } from '../../../common/util/global-scope';
+import { isBrowserScope } from '../../../common/constants/runtime';
 const {
   BST_RESOURCE,
   RESOURCE,
-  BST_TIMER,
   START,
   END,
   FEATURE_NAME,
@@ -28,8 +27,6 @@ export class Instrument extends InstrumentBase {
     if (!isBrowserScope) return; // session traces not supported outside web env
 
     const thisInstrumentEE = this.ee;
-    this.timerEE = wrapTimer(thisInstrumentEE);
-    this.rafEE = wrapRaf(thisInstrumentEE);
     wrapHistory(thisInstrumentEE);
     this.eventsEE = wrapEvents(thisInstrumentEE);
     this.eventsEE.on(FN_START, function (args, target) {
@@ -40,19 +37,6 @@ export class Instrument extends InstrumentBase {
       // When ajax is disabled, this may fail without making ajax a dependency of session_trace
       handle('bst', [args[0], target, this.bstStart, now()], undefined, FEATURE_NAMES.sessionTrace, thisInstrumentEE);
     });
-    this.timerEE.on(FN_START, function (args, obj, type) {
-      this.bstStart = now();
-      this.bstType = type;
-    });
-    this.timerEE.on(FN_END, function (args, target) {
-      handle(BST_TIMER, [target, this.bstStart, now(), this.bstType], undefined, FEATURE_NAMES.sessionTrace, thisInstrumentEE);
-    });
-    this.rafEE.on(FN_START, function () {
-      this.bstStart = now();
-    });
-    this.rafEE.on(FN_END, function (args, target) {
-      handle(BST_TIMER, [target, this.bstStart, now(), 'requestAnimationFrame'], undefined, FEATURE_NAMES.sessionTrace, thisInstrumentEE);
-    });
     thisInstrumentEE.on(PUSH_STATE + START, function (args) {
       this.time = now();
       this.startPath = location.pathname + location.hash;

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

@@ -619,7 +619,7 @@ export class Aggregate extends AggregateBase {
     function onHarvestFinished(result) {
       if (result.sent && result.retry && state.interactionsSent.length > 0) {
         state.interactionsSent.forEach(function (interaction) {
-          state.interactionsToHarvest.push(interaction);
+          state.interactionsToHarvest.unshift(interaction);
         });
         state.interactionsSent = [];
       }

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

@@ -1,5 +1,4 @@
 import { originals } from '../../common/config/config';
-import { globalScope } from '../../common/util/global-scope';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 export const FEATURE_NAME = FEATURE_NAMES.spa;
 export const INTERACTION_EVENTS = ['click', 'submit', 'keypress', 'keydown', 'keyup', 'change'];

package/dist/esm/features/spa/instrument/index.js

@@ -8,7 +8,7 @@ import { InstrumentBase } from '../../utils/instrument-base';
 import { getRuntime } from '../../../common/config/config';
 import { now } from '../../../common/timing/now';
 import * as CONSTANTS from '../constants';
-import { isBrowserScope } from '../../../common/util/global-scope';
+import { isBrowserScope } from '../../../common/constants/runtime';
 const {
   FEATURE_NAME,
   START,

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

@@ -1,8 +1,7 @@
-import { getConfigurationValue, getInfo, getRuntime, setInfo } from '../../common/config/config';
+import { getConfiguration, getInfo, getRuntime } from '../../common/config/config';
 import { drain } from '../../common/drain/drain';
 import { ee } from '../../common/event-emitter/contextual-ee';
 import { registerHandler } from '../../common/event-emitter/register-handler';
-import { isBrowserScope } from '../../common/util/global-scope';
 import { SessionEntity } from '../../common/session/session-entity';
 import { LocalStorage } from '../../common/storage/local-storage.js';
 import { FirstPartyCookies } from '../../common/storage/first-party-cookies';
@@ -10,43 +9,28 @@ let ranOnce = 0;
 export function setupAgentSession(agentIdentifier) {
   const agentRuntime = getRuntime(agentIdentifier);
   if (ranOnce++) return agentRuntime.session;
-  const sharedEE = ee.get(agentIdentifier);
+  const sessionInit = 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(sessionInit.domain) : new LocalStorage();
+  agentRuntime.session = new 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 = getConfigurationValue(agentIdentifier, 'privacy.cookies_enabled') === true;
-  if (cookiesEnabled && isBrowserScope) {
-    storageAPI = getConfigurationValue(agentIdentifier, 'session.domain') ? new FirstPartyCookies(getConfigurationValue(agentIdentifier, 'session.domain')) : new LocalStorage();
-  }
-  if (cookiesEnabled) {
-    // defaults to "LocalMemory" if storageAPI is undefined, such as in Worker build
-    agentRuntime.session = new SessionEntity({
-      agentIdentifier,
-      key: 'SESSION',
-      storageAPI,
-      expiresMs: getConfigurationValue(agentIdentifier, 'session.expiresMs'),
-      inactiveMs: 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 (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 = getInfo(agentIdentifier);
-    if (customSessionData) {
-      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 = getInfo(agentIdentifier);
+  if (customSessionData) {
+    agentInfo.jsAttributes = {
+      ...agentInfo.jsAttributes,
+      ...customSessionData
+    };
   }
+  const sharedEE = ee.get(agentIdentifier);
 
   // any calls to newrelic.setCustomAttribute(<persisted>) will need to be added to:
   // local info.jsAttributes {}

package/dist/esm/features/utils/aggregate-base.js

@@ -8,21 +8,16 @@ export class AggregateBase extends FeatureBase {
     super(...arguments);
     this.checkConfiguration();
   }
+
+  /**
+   * New handler for waiting for multiple flags. Useful when expecting multiple flags simultaneously (ex. stn vs sr)
+   * @param {string[]} flagNames
+   * @returns
+   */
   waitForFlags() {
     let flagNames = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
     return Promise.all(flagNames.map(fName => new Promise(resolve => {
-      registerHandler("feat-".concat(fName), () => {
-        resolve({
-          name: fName,
-          value: true
-        });
-      }, this.featureName, this.ee);
-      registerHandler("block-".concat(fName), () => {
-        resolve({
-          name: fName,
-          value: false
-        });
-      }, this.feature, this.ee);
+      registerHandler("rumresp-".concat(fName), isOn => resolve(isOn), this.featureName, this.ee);
     })));
   }