@newrelic/browser-agent 1.258.2 → 1.260.0

package/dist/cjs/features/session_trace/aggregate/trace/node.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TraceNode = void 0;
+/**
+ * All nodes reported to the consumer must take this shape
+ */
+class TraceNode {
+  constructor(name, start, end, origin, type) {
+    this.n = name;
+    this.s = start;
+    this.e = end;
+    this.o = origin;
+    this.t = type;
+  }
+}
+exports.TraceNode = TraceNode;

package/dist/cjs/features/session_trace/aggregate/trace/storage.js

@@ -0,0 +1,289 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TraceStorage = void 0;
+var _runtime = require("../../../../common/constants/runtime");
+var _constants = require("../../../../common/session/constants");
+var _now = require("../../../../common/timing/now");
+var _parseUrl = require("../../../../common/url/parse-url");
+var _constants2 = require("../../constants");
+var _node = require("./node");
+const ERROR_MODE_SECONDS_WINDOW = 30 * 1000; // sliding window of nodes to track when simply monitoring (but not harvesting) in error mode
+const SUPPORTS_PERFORMANCE_OBSERVER = typeof _runtime.globalScope.PerformanceObserver === 'function';
+const ignoredEvents = {
+  // we find that certain events make the data too noisy to be useful
+  global: {
+    mouseup: true,
+    mousedown: true
+  },
+  // certain events are present both in the window and in PVT metrics.  PVT metrics are prefered so the window events should be ignored
+  window: {
+    load: true,
+    pagehide: true
+  },
+  // when ajax instrumentation is disabled, all XMLHttpRequest events will return with origin = xhrOriginMissing and should be ignored
+  xhrOriginMissing: {
+    ignoreAll: true
+  }
+};
+const toAggregate = {
+  typing: [1000, 2000],
+  scrolling: [100, 1000],
+  mousing: [1000, 2000],
+  touching: [1000, 2000]
+};
+
+/** The purpose of this class is to manage, normalize, and retrieve ST nodes as needed without polluting the main ST modules */
+class TraceStorage {
+  nodeCount = 0;
+  trace = {};
+  earliestTimeStamp = Infinity;
+  latestTimeStamp = 0;
+  tempStorage = [];
+  prevStoredEvents = new Set();
+  constructor(parent) {
+    this.parent = parent;
+  }
+
+  /** Central function called by all the other store__ & addToTrace API to append a trace node. */
+  storeSTN(stn) {
+    if (this.parent.blocked) return;
+    if (this.nodeCount >= _constants2.MAX_NODES_PER_HARVEST) {
+      // limit the amount of pending data awaiting next harvest
+      if (this.parent.agentRuntime.session.state.sessionTraceMode !== _constants.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;
+    }
+    while (this.tempStorage.length) {
+      this.storeSTN(this.tempStorage.shift());
+    }
+    if (this.trace[stn.n]) this.trace[stn.n].push(stn);else this.trace[stn.n] = [stn];
+    if (stn.s < this.earliestTimeStamp) this.earliestTimeStamp = stn.s;
+    if (stn.s > this.latestTimeStamp) this.latestTimeStamp = stn.s;
+    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() {
+    if (!SUPPORTS_PERFORMANCE_OBSERVER) {
+      // if PO isn't supported, this checks resourcetiming buffer every harvest.
+      this.storeResources(_runtime.globalScope.performance?.getEntriesByType?.('resource'));
+    }
+    const stns = Object.entries(this.trace).flatMap(_ref => {
+      let [name, listOfSTNodes] = _ref;
+      // 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:
+      const reindexByOriginFn = this.smearEvtsByOrigin(name);
+      const partitionListByOriginMap = listOfSTNodes.sort((a, b) => a.s - b.s).reduce(reindexByOriginFn, {});
+      return Object.values(partitionListByOriginMap).flat(); // join the partitions back into 1-D, now ordered by origin then start time
+    }, this);
+    if (stns.length === 0) return {};
+    this.trace = {};
+    this.nodeCount = 0;
+    const earliestTimeStamp = this.earliestTimeStamp;
+    this.earliestTimeStamp = Infinity;
+    const latestTimeStamp = this.latestTimeStamp;
+    this.latestTimeStamp = 0;
+    return {
+      stns,
+      earliestTimeStamp,
+      latestTimeStamp
+    };
+  }
+  smearEvtsByOrigin(name) {
+    const maxGap = toAggregate[name][0];
+    const maxLen = toAggregate[name][1];
+    const lastO = {};
+    return (byOrigin, evtNode) => {
+      let lastArr = byOrigin[evtNode.o];
+      if (!lastArr) lastArr = byOrigin[evtNode.o] = [];
+      const last = lastO[evtNode.o];
+      if (name === 'scrolling' && !trivial(evtNode)) {
+        lastO[evtNode.o] = null;
+        evtNode.n = 'scroll';
+        lastArr.push(evtNode);
+      } else if (last && evtNode.s - last.s < maxLen && last.e > evtNode.s - maxGap) {
+        last.e = evtNode.e;
+      } else {
+        lastO[evtNode.o] = evtNode;
+        lastArr.push(evtNode);
+      }
+      return byOrigin;
+    };
+    function trivial(node) {
+      const limit = 4;
+      return !!(node && typeof node.e === 'number' && typeof node.s === 'number' && node.e - node.s < limit);
+    }
+  }
+  processPVT(name, value, attrs) {
+    this.storeTiming({
+      [name]: value
+    });
+    if (hasFID(name, attrs)) this.storeEvent({
+      type: 'fid',
+      target: 'document'
+    }, 'document', value, value + attrs.fid);
+    function hasFID(name, attrs) {
+      return name === 'fi' && !!attrs && typeof attrs.fid === 'number';
+    }
+  }
+  storeTiming(timingEntry) {
+    if (!timingEntry) return;
+
+    // loop iterates through prototype also (for FF)
+    for (let key in timingEntry) {
+      let val = timingEntry[key];
+
+      // ignore size and status type nodes that do not map to timestamp metrics
+      const lck = key.toLowerCase();
+      if (lck.indexOf('size') >= 0 || lck.indexOf('status') >= 0) continue;
+
+      // ignore inherited methods, meaningless 0 values, and bogus timestamps
+      // that are in the future (Microsoft Edge seems to sometimes produce these)
+      if (!(typeof val === 'number' && val >= 0)) continue;
+      val = Math.round(val);
+      this.storeSTN(new _node.TraceNode(key, val, val, 'document', 'timing'));
+    }
+  }
+
+  // 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;
+    if (this.prevStoredEvents.has(currentEvent)) return; // prevent multiple listeners of an event from creating duplicate trace nodes per occurrence. Cleared every harvest. near-zero chance for re-duplication after clearing per harvest since the timestamps of the event are considered for uniqueness.
+    this.prevStoredEvents.add(currentEvent);
+    const evt = new _node.TraceNode(this.evtName(currentEvent.type), start, end, undefined, 'event');
+    try {
+      // webcomponents-lite.js can trigger an exception on currentEvent.target getter because
+      // it does not check currentEvent.currentTarget before calling getRootNode() on it
+      evt.o = this.evtOrigin(currentEvent.target, target);
+    } catch (e) {
+      evt.o = this.evtOrigin(null, target);
+    }
+    this.storeSTN(evt);
+  }
+  shouldIgnoreEvent(event, target) {
+    const origin = this.evtOrigin(event.target, target);
+    if (event.type in ignoredEvents.global) return true;
+    if (!!ignoredEvents[origin] && ignoredEvents[origin].ignoreAll) return true;
+    return !!(!!ignoredEvents[origin] && event.type in ignoredEvents[origin]);
+  }
+  evtName(type) {
+    switch (type) {
+      case 'keydown':
+      case 'keyup':
+      case 'keypress':
+        return 'typing';
+      case 'mousemove':
+      case 'mouseenter':
+      case 'mouseleave':
+      case 'mouseover':
+      case 'mouseout':
+        return 'mousing';
+      case 'scroll':
+        return 'scrolling';
+      case 'touchstart':
+      case 'touchmove':
+      case 'touchend':
+      case 'touchcancel':
+      case 'touchenter':
+      case 'touchleave':
+        return 'touching';
+      default:
+        return type;
+    }
+  }
+  evtOrigin(t, target) {
+    let origin = 'unknown';
+    if (t && t instanceof XMLHttpRequest) {
+      const params = this.parent.ee.context(t).params;
+      if (!params || !params.status || !params.method || !params.host || !params.pathname) return 'xhrOriginMissing';
+      origin = params.status + ' ' + params.method + ': ' + params.host + params.pathname;
+    } else if (t && typeof t.tagName === 'string') {
+      origin = t.tagName.toLowerCase();
+      if (t.id) origin += '#' + t.id;
+      if (t.className) {
+        for (let i = 0; i < t.classList.length; i++) origin += '.' + t.classList[i];
+      }
+    }
+    if (origin === 'unknown') {
+      if (typeof target === 'string') origin = target;else if (target === document) origin = 'document';else if (target === window) origin = 'window';else if (target instanceof FileReader) origin = 'FileReader';
+    }
+    return origin;
+  }
+
+  // Tracks when the window history API specified by wrap-history is used.
+  storeHist(path, old, time) {
+    this.storeSTN(new _node.TraceNode('history.pushState', time, time, path, old));
+  }
+  #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
+
+      const {
+        initiatorType,
+        fetchStart,
+        responseEnd,
+        entryType
+      } = currentResource;
+      const {
+        protocol,
+        hostname,
+        port,
+        pathname
+      } = (0, _parseUrl.parseUrl)(currentResource.name);
+      const res = new _node.TraceNode(initiatorType, fetchStart | 0, responseEnd | 0, "".concat(protocol, "://").concat(hostname, ":").concat(port).concat(pathname), entryType);
+      this.storeSTN(res);
+    });
+    this.#laststart = resources[resources.length - 1].fetchStart | 0;
+  }
+
+  // JavascriptError (FEATURE) events pipes into ST here.
+  storeErrorAgg(type, name, params, metrics) {
+    if (type !== 'err') return; // internal errors are purposefully ignored
+    this.storeSTN(new _node.TraceNode('error', metrics.time, metrics.time, params.message, params.stackHash));
+  }
+
+  // Ajax (FEATURE) events--XML & fetches--pipes into ST here.
+  storeXhrAgg(type, name, params, metrics) {
+    if (type !== 'xhr') return;
+    this.storeSTN(new _node.TraceNode('Ajax', metrics.time, metrics.time + metrics.duration, "".concat(params.status, " ").concat(params.method, ": ").concat(params.host).concat(params.pathname)));
+  }
+  restoreNode(name, listOfSTNodes) {
+    if (this.nodeCount >= _constants2.MAX_NODES_PER_HARVEST) return;
+    this.nodeCount += listOfSTNodes.length;
+    this.trace[name] = this.trace[name] ? listOfSTNodes.concat(this.trace[name]) : listOfSTNodes;
+  }
+}
+exports.TraceStorage = TraceStorage;

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_RESOURCE = void 0;
+exports.START = exports.RESOURCE = exports.PUSH_STATE = exports.MAX_NODES_PER_HARVEST = 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 = exports.FEATURE_NAME = _features.FEATURE_NAMES.sessionTrace;
 const BST_RESOURCE = exports.BST_RESOURCE = 'bstResource';
@@ -12,4 +12,5 @@ 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';
+const PUSH_STATE = exports.PUSH_STATE = 'pushState';
+const MAX_NODES_PER_HARVEST = exports.MAX_NODES_PER_HARVEST = 1000;

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

@@ -9,7 +9,8 @@ var _wrap = require("../../../common/wrap");
 var _instrumentBase = require("../../utils/instrument-base");
 var CONSTANTS = _interopRequireWildcard(require("../constants"));
 var _features = require("../../../loaders/features/features");
-var _runtime = require("../../../common/constants/runtime");
+var _drain = require("../../../common/drain/drain");
+var _featureGates = require("../../utils/feature-gates");
 var _now = require("../../../common/timing/now");
 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; }
@@ -33,8 +34,11 @@ class Instrument extends _instrumentBase.InstrumentBase {
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
-    if (!_runtime.isBrowserScope) return; // session traces not supported outside web env
-
+    const canTrackSession = (0, _featureGates.canEnableSessionTracking)(this.agentIdentifier);
+    if (!canTrackSession) {
+      (0, _drain.deregisterDrain)(this.agentIdentifier, this.featureName);
+      return;
+    }
     const thisInstrumentEE = this.ee;
     (0, _wrap.wrapHistory)(thisInstrumentEE);
     this.eventsEE = (0, _wrap.wrapEvents)(thisInstrumentEE);

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

@@ -42,6 +42,7 @@ class AggregateBase extends _featureBase.FeatureBase {
   }
   drain() {
     (0, _drain.drain)(this.agentIdentifier, this.featureName);
+    this.drained = true;
   }
 
   /**

package/dist/cjs/features/utils/feature-gates.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canEnableSessionTracking = void 0;
+var _config = require("../../common/config/config");
+var _runtime = require("../../common/constants/runtime");
+/**
+ * Checks if session can be tracked, affects session entity and dependent features
+ * @param {string} agentId
+ * @returns {boolean}
+ */
+const canEnableSessionTracking = agentId => {
+  return _runtime.isBrowserScope && (0, _config.getConfigurationValue)(agentId, 'privacy.cookies_enabled') === true;
+};
+exports.canEnableSessionTracking = canEnableSessionTracking;

package/dist/cjs/features/utils/instrument-base.js

@@ -12,6 +12,7 @@ var _console = require("../../common/util/console");
 var _features = require("../../loaders/features/features");
 var _config = require("../../common/config/config");
 var _utils = require("../session_replay/shared/utils");
+var _featureGates = require("./feature-gates");
 var _invoke = require("../../common/util/invoke");
 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; } /**
@@ -83,7 +84,7 @@ class InstrumentBase extends _featureBase.FeatureBase {
     const importLater = async () => {
       let session;
       try {
-        if ((0, _utils.enableSessionTracking)(this.agentIdentifier)) {
+        if ((0, _featureGates.canEnableSessionTracking)(this.agentIdentifier)) {
           // would require some setup before certain features start
           const {
             setupAgentSession

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

@@ -7,6 +7,7 @@ exports.AgentBase = void 0;
 var _console = require("../common/util/console");
 var _constants = require("../features/session_replay/constants");
 var _uniqueId = require("../common/ids/unique-id");
+var _contextualEe = require("../common/event-emitter/contextual-ee");
 /* eslint-disable n/handle-callback-err */
 
 /**
@@ -18,6 +19,9 @@ class AgentBase {
   constructor() {
     let agentIdentifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (0, _uniqueId.generateRandomHexString)(16);
     this.agentIdentifier = agentIdentifier;
+
+    // Assign the observation context to the event emitter, so it knows how to create observation contexts
+    this.ee = _contextualEe.ee.get(agentIdentifier);
   }
 
   /**

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

@@ -5,5 +5,5 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.asyncApiMethods = exports.apiMethods = void 0;
 var _constants = require("../../features/session_replay/constants");
-const apiMethods = exports.apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', 'recordReplay', 'pauseReplay', _constants.SR_EVENT_EMITTER_TYPES.RECORD, _constants.SR_EVENT_EMITTER_TYPES.PAUSE];
+const apiMethods = exports.apiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start', _constants.SR_EVENT_EMITTER_TYPES.RECORD, _constants.SR_EVENT_EMITTER_TYPES.PAUSE];
 const asyncApiMethods = exports.asyncApiMethods = ['setErrorHandler', 'finished', 'addToTrace', 'addRelease'];

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

@@ -206,8 +206,8 @@ function setAPI(agentIdentifier, forceDrain) {
       } = _ref;
       setAPI(agentIdentifier);
       (0, _drain.drain)(agentIdentifier, 'api');
-    }).catch(() => {
-      (0, _console.warn)('Downloading runtime APIs failed...');
+    }).catch(err => {
+      (0, _console.warn)('Downloading runtime APIs failed...', err);
       instanceEE.abort();
     });
   }

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

@@ -60,6 +60,7 @@ function configure(agent) {
     agent.runSoftNavOverSpa &&= updatedInit.soft_navigations.enabled === true && updatedInit.feature_flags.includes('soft_nav');
   }
   runtime.denyList = [...(updatedInit.ajax.deny_list || []), ...(updatedInit.ajax.block_internal ? internalTrafficList : [])];
+  runtime.ptid = agent.agentIdentifier;
   (0, _config.setRuntime)(agent.agentIdentifier, runtime);
   if (agent.api === undefined) agent.api = (0, _api.setAPI)(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa);
   if (agent.exposed === undefined) agent.exposed = exposed;

package/dist/esm/cdn/polyfills.js

@@ -10,6 +10,7 @@ import 'core-js/stable/array/flat';
 import 'core-js/stable/array/flat-map';
 import 'core-js/stable/array/from';
 import 'core-js/stable/array/some';
+import 'core-js/stable/array/find-index';
 import 'core-js/stable/object/assign';
 import 'core-js/stable/object/entries';
 import 'core-js/stable/object/values';
@@ -22,4 +23,5 @@ import 'core-js/stable/object/get-own-property-descriptors';
 import 'core-js/stable/url';
 import 'core-js/stable/url-search-params';
 import 'core-js/stable/string/starts-with';
-import 'core-js/stable/number/is-nan';
+import 'core-js/stable/number/is-nan';
+import 'core-js/stable/string/includes';

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

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

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

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

package/dist/esm/common/drain/drain.js

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

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

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

package/dist/esm/common/session/session-entity.js

@@ -69,8 +69,15 @@ export class SessionEntity {
       expiresMs = DEFAULT_EXPIRES_MS,
       inactiveMs = DEFAULT_INACTIVE_MS
     } = _ref;
+    /** Ensure that certain properties are preserved across a reset if already set */
+    const persistentAttributes = {
+      serverTimeDiff: this.state.serverTimeDiff || model.serverTimeDiff
+    };
     this.state = {};
-    this.sync(model);
+    this.sync({
+      ...model,
+      ...persistentAttributes
+    });
 
     // value is intended to act as the primary value of the k=v pair
     this.state.value = value;

package/dist/esm/common/timing/time-keeper.js

@@ -1,7 +1,5 @@
 import { originTime } from '../constants/runtime';
-import { ee as baseEE } from '../event-emitter/contextual-ee';
 import { getRuntime } from '../config/config';
-import { SESSION_EVENT_TYPES, SESSION_EVENTS } from '../session/constants';
 
 /**
  * Class used to adjust the timestamp of harvested data to New Relic server time. This
@@ -36,18 +34,7 @@ export class TimeKeeper {
   #ready = false;
   constructor(agentIdentifier) {
     this.#session = getRuntime(agentIdentifier)?.session;
-    if (this.#session) {
-      const ee = baseEE.get(agentIdentifier);
-      ee.on(SESSION_EVENTS.UPDATE, this.#processSessionUpdate.bind(this));
-      ee.on(SESSION_EVENTS.STARTED, () => {
-        if (this.#ready) {
-          this.#session.write({
-            serverTimeDiff: this.#localTimeDiff
-          });
-        }
-      });
-      this.#processSessionUpdate(null, this.#session.read());
-    }
+    this.processStoredDiff();
   }
   get ready() {
     return this.#ready;
@@ -63,8 +50,8 @@ export class TimeKeeper {
    * @param endTime {number} The end time of the RUM request
    */
   processRumRequest(rumRequest, startTime, endTime) {
+    this.processStoredDiff();
     if (this.#ready) return; // Server time calculated from session entity
-
     const responseDateHeader = rumRequest.getResponseHeader('Date');
     if (!responseDateHeader) {
       throw new Error('Missing date header on rum response.');
@@ -75,10 +62,10 @@ export class TimeKeeper {
     // Corrected page origin time
     this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset);
     this.#localTimeDiff = originTime - this.#correctedOriginTime;
-    if (Number.isNaN(this.#correctedOriginTime)) {
+    if (isNaN(this.#correctedOriginTime)) {
       throw new Error('Date header invalid format.');
     }
-    if (this.#session) this.#session.write({
+    this.#session?.write({
       serverTimeDiff: this.#localTimeDiff
     });
     this.#ready = true;
@@ -103,19 +90,11 @@ export class TimeKeeper {
     return Math.floor(timestamp - this.#localTimeDiff);
   }
 
-  /**
-   * Processes a session entity update payload to extract the server time calculated.
-   * @param {import('../session/constants').SESSION_EVENT_TYPES | null} type
-   * @param {Object} data
-   */
-  #processSessionUpdate(type, data) {
-    if (typeof data?.serverTimeDiff !== 'number') return;
-    if (!type && !this.#ready ||
-    // This captures the initial read from the session entity when the timekeeper first initializes
-    type === SESSION_EVENT_TYPES.CROSS_TAB // This captures any cross-tab write of the session entity
-    ) {
-      // This captures the initial read from the session entity when the timekeeper first initializes
-      this.#localTimeDiff = data.serverTimeDiff;
+  /** Process the session entity and use the info to set the main time calculations if present */
+  processStoredDiff() {
+    const storedServerTimeDiff = this.#session?.read()?.serverTimeDiff;
+    if (typeof storedServerTimeDiff === 'number' && !isNaN(storedServerTimeDiff)) {
+      this.#localTimeDiff = storedServerTimeDiff;
       this.#correctedOriginTime = originTime - this.#localTimeDiff;
       this.#ready = true;
     }

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

@@ -1,2 +1,3 @@
 import { FEATURE_NAMES } from '../../loaders/features/features';
-export const FEATURE_NAME = FEATURE_NAMES.ajax;
+export const FEATURE_NAME = FEATURE_NAMES.ajax;
+export const MAX_PAYLOAD_SIZE = 1000000;

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

@@ -6,7 +6,6 @@
 import { handle } from '../../../common/event-emitter/handle';
 import { InstrumentBase } from '../../utils/instrument-base';
 import { FEATURE_NAME } from '../constants';
-import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { globalScope } from '../../../common/constants/runtime';
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts';
 import { now } from '../../../common/timing/now';
@@ -24,7 +23,7 @@ export class Instrument extends InstrumentBase {
     } catch (e) {}
     this.ee.on('internal-error', error => {
       if (!this.abortHandler) return;
-      handle('ierr', [castError(error), now(), true, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee);
+      handle('ierr', [castError(error), now(), true, {}, this.#replayRunning], undefined, this.featureName, this.ee);
     });
     this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
       this.#replayRunning = isRunning;
@@ -33,11 +32,11 @@ export class Instrument extends InstrumentBase {
       if (!this.abortHandler) return;
       handle('err', [castPromiseRejectionEvent(promiseRejectionEvent), now(), false, {
         unhandledPromiseRejection: 1
-      }, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee);
+      }, this.#replayRunning], undefined, this.featureName, this.ee);
     }, eventListenerOpts(false, this.removeOnAbort?.signal));
     globalScope.addEventListener('error', errorEvent => {
       if (!this.abortHandler) return;
-      handle('err', [castErrorEvent(errorEvent), now(), false, {}, this.#replayRunning], undefined, FEATURE_NAMES.jserrors, this.ee);
+      handle('err', [castErrorEvent(errorEvent), now(), false, {}, this.#replayRunning], undefined, this.featureName, this.ee);
     }, eventListenerOpts(false, this.removeOnAbort?.signal));
     this.abortHandler = this.#abort; // we also use this as a flag to denote that the feature is active or on and handling errors
     this.importAggregator();