@newrelic/browser-agent 0.0.9 → 0.1.229

package/dist/cjs/features/spa/aggregate/interaction-node.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InteractionNode = InteractionNode;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var MAX_NODES = 128;
+var lastId = 0;
+function InteractionNode(interaction, parent, type, timestamp) {
+  Object.defineProperty(this, 'interaction', {
+    value: interaction,
+    writable: true // enumerable: false -- by default, which hides this prop from obj (iterations)
+  });
+
+  this.parent = parent;
+  this.id = ++lastId;
+  this.type = type;
+  this.children = [];
+  this.end = null;
+  this.jsEnd = this.start = timestamp;
+  this.jsTime = 0;
+  this.attrs = {};
+  this.cancelled = false;
+}
+var InteractionNodePrototype = InteractionNode.prototype;
+
+/**
+ * @param {string} type
+ * @param {number} timestamp
+ * @param {string} name
+ * @param {bool} dontWait - When true, the interaction will not immediately start waiting
+ *                          for this node to complete. This is used when the creation of
+ *                          the node and its start happen at different times (e.g. XHR).
+ */
+InteractionNodePrototype.child = function child(type, timestamp, name, dontWait) {
+  var interaction = this.interaction;
+  if (interaction.end || interaction.nodes >= MAX_NODES) return null;
+  interaction.onNodeAdded(this);
+  var node = new InteractionNode(interaction, this, type, timestamp);
+  node.attrs.name = name;
+  interaction.nodes++;
+  if (!dontWait) {
+    interaction.remaining++;
+  }
+  return node;
+};
+InteractionNodePrototype.callback = function addCallbackTime(exclusiveTime, end) {
+  var node = this;
+  node.jsTime += exclusiveTime;
+  if (end > node.jsEnd) {
+    node.jsEnd = end;
+    node.interaction.lastCb = end;
+  }
+};
+InteractionNodePrototype.cancel = function cancel() {
+  this.cancelled = true;
+  var interaction = this.interaction;
+  interaction.remaining--;
+};
+InteractionNodePrototype.finish = function finish(timestamp) {
+  var node = this;
+  if (node.end) return;
+  node.end = timestamp;
+
+  // Find the next parent node that is not cancelled
+  let parent = node.parent;
+  while (parent?.cancelled) parent = parent.parent;
+
+  // Assign the node to the non-cancelled parent node
+  if (parent) parent.children.push(node);
+  node.parent = null;
+
+  // Update the interaction remaining counter
+  var interaction = this.interaction;
+  interaction.remaining--;
+  interaction.lastFinish = timestamp;
+  // check if interaction has finished, (this is needed for older browsers for unknown reasons)
+  interaction.checkFinish();
+};

package/dist/cjs/features/spa/aggregate/interaction-node.test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+var _interactionNode = require("./interaction-node");
+test('finishing node with cancelled parent should not throw an error', () => {
+  const interaction = {
+    remaining: 0,
+    onNodeAdded: jest.fn(),
+    checkFinish: jest.fn()
+  };
+  const interactionRootNode = new _interactionNode.InteractionNode(interaction, null, 'interaction', _faker.faker.date.past().getUTCSeconds());
+  const interactionNode = interactionRootNode.child('test', _faker.faker.date.past().getUTCSeconds(), 'test', false);
+  interactionRootNode.cancel();
+  interactionNode.finish();
+  expect(interactionRootNode.children.length).toEqual(0);
+});

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

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Interaction = Interaction;
+var _config = require("../../../common/config/config");
+var _mapOwn = require("../../../common/util/map-own");
+var _contextualEe = require("../../../common/event-emitter/contextual-ee");
+var _interactionNode = require("./interaction-node");
+var _now = require("../../../common/timing/now");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var originalSetTimeout = _config.originals.ST;
+var originalClearTimeout = _config.originals.CT;
+var lastId = {};
+function Interaction(eventName, timestamp, url, routeName, onFinished, agentIdentifier) {
+  this.agentIdentifier = agentIdentifier;
+  this.ee = _contextualEe.ee.get(agentIdentifier);
+  lastId[agentIdentifier] = 0;
+  this.id = ++lastId[agentIdentifier];
+  this.eventName = eventName;
+  this.nodes = 0;
+  this.remaining = 0;
+  this.finishTimer = null;
+  this.checkingFinish = false;
+  this.lastCb = this.lastFinish = timestamp;
+  this.handlers = [];
+  this.onFinished = onFinished;
+  this.done = false;
+  var root = this.root = new _interactionNode.InteractionNode(this, null, 'interaction', timestamp);
+  var attrs = root.attrs;
+  attrs.trigger = eventName;
+  attrs.initialPageURL = (0, _config.getRuntime)(agentIdentifier).origin;
+  attrs.oldRoute = routeName;
+  attrs.newURL = attrs.oldURL = url;
+  attrs.custom = {};
+  attrs.store = {};
+}
+var InteractionPrototype = Interaction.prototype;
+InteractionPrototype.checkFinish = function checkFinish() {
+  var interaction = this;
+  if (interaction.remaining > 0) {
+    interaction._resetFinishCheck();
+    return;
+  }
+  if (interaction.checkingFinish) {
+    return;
+  }
+  if (interaction.root.end !== null) return;
+  interaction._resetFinishCheck();
+  interaction.checkingFinish = true;
+  interaction.finishTimer = originalSetTimeout(() => {
+    interaction.checkingFinish = false;
+    interaction.finishTimer = originalSetTimeout(() => {
+      interaction.finishTimer = null;
+      if (interaction.remaining <= 0) interaction.finish();
+    }, 1);
+  }, 0);
+};
+InteractionPrototype.setNewURL = function setNewURL(url) {
+  this.root.attrs.newURL = url;
+};
+InteractionPrototype.setNewRoute = function setNewRoute(route) {
+  this.root.attrs.newRoute = route;
+};
+InteractionPrototype.onNodeAdded = function onNodeAdded() {
+  this._resetFinishCheck();
+};
+InteractionPrototype._resetFinishCheck = function _resetFinishCheck() {
+  if (this.finishTimer) {
+    originalClearTimeout(this.finishTimer);
+    this.finishTimer = null;
+    this.checkingFinish = false;
+  }
+};
+
+// serialize report and remove nodes from map
+InteractionPrototype.finish = function finishInteraction() {
+  var interaction = this;
+  var root = interaction.root;
+  if (root.end !== null) return;
+  var endTimestamp = Math.max(interaction.lastCb, interaction.lastFinish);
+  var delta = (0, _now.now)() - endTimestamp;
+  var attrs = root.attrs;
+  var customAttrs = attrs.custom;
+  if (this.onFinished) {
+    this.onFinished(this);
+  }
+  (0, _mapOwn.mapOwn)((0, _config.getInfo)(interaction.agentIdentifier).jsAttributes, function (attr, value) {
+    if (!(attr in customAttrs)) customAttrs[attr] = value;
+  });
+  root.end = endTimestamp;
+  interaction.ee.emit('interaction', [this]);
+};

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

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Serializer = void 0;
+var _cleanUrl = require("../../../common/url/clean-url");
+var _mapOwn = require("../../../common/util/map-own");
+var _belSerializer = require("../../../common/serialize/bel-serializer");
+var _sharedContext = require("../../../common/context/shared-context");
+var _config = require("../../../common/config/config");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+class Serializer extends _sharedContext.SharedContext {
+  constructor(parent) {
+    super(parent);
+
+    /**
+     * This variable is used to calculate an interactions ending offset when the
+     * harvest includes multiple interactions. This variable is set by the first
+     * interaction processed and used by subsequent interactions in the same harvest.
+     * See https://issues.newrelic.com/browse/NEWRELIC-5498
+     * @type {number|undefined}
+     */
+    this.firstTimestamp = undefined;
+  }
+  serializeMultiple(interactions, offset, navTiming) {
+    const info = (0, _config.getInfo)(this.sharedContext.agentIdentifier);
+    var addString = (0, _belSerializer.getAddStringContext)(this.sharedContext.agentIdentifier);
+    var serialized = 'bel.7';
+    interactions.forEach(interaction => {
+      serialized += ';' + this.serializeInteraction(interaction.root, offset, navTiming, interaction.routeChange, addString, info);
+    });
+    this.firstTimestamp = undefined;
+    return serialized;
+  }
+  serializeSingle(root, offset, navTiming, isRouteChange) {
+    const info = (0, _config.getInfo)(this.sharedContext.agentIdentifier);
+    var addString = (0, _belSerializer.getAddStringContext)(this.sharedContext.agentIdentifier);
+    var serialized = 'bel.7;' + this.serializeInteraction(root, offset, navTiming, isRouteChange, addString, info);
+    this.firstTimestamp = undefined;
+    return serialized;
+  }
+  serializeInteraction(root, offset, navTiming, isRouteChange, addString, info) {
+    offset = offset || 0;
+    var isInitialPage = root.attrs.trigger === 'initialPageLoad';
+    var typeIdsByName = {
+      interaction: 1,
+      ajax: 2,
+      customTracer: 4
+    };
+
+    // Include the hash fragment with all SPA data
+    var includeHashFragment = true;
+    const addNode = (node, nodeList) => {
+      if (node.type === 'customEnd') return nodeList.push([3, (0, _belSerializer.numeric)(node.end - this.firstTimestamp)]);
+      var typeName = node.type;
+      var typeId = typeIdsByName[typeName];
+      var startTimestamp = node.start;
+      var childCount = node.children.length;
+      var attrCount = 0;
+      var apmAttributes = info.atts;
+      var hasNavTiming = isInitialPage && navTiming.length && typeId === 1;
+      var children = [];
+      var attrs = node.attrs;
+      var metrics = attrs.metrics;
+      var params = attrs.params;
+      var queueTime = info.queueTime;
+      var appTime = info.applicationTime;
+      if (typeof this.firstTimestamp === 'undefined') {
+        startTimestamp += offset;
+        this.firstTimestamp = startTimestamp;
+      } else {
+        startTimestamp -= this.firstTimestamp;
+      }
+      var fields = [(0, _belSerializer.numeric)(startTimestamp), (0, _belSerializer.numeric)(node.end - node.start), (0, _belSerializer.numeric)(node.jsEnd - node.end), (0, _belSerializer.numeric)(node.jsTime)];
+      switch (typeId) {
+        case 1:
+          fields[2] = (0, _belSerializer.numeric)(node.jsEnd - this.firstTimestamp);
+          fields.push(addString(attrs.trigger), addString((0, _cleanUrl.cleanURL)(attrs.initialPageURL, includeHashFragment)), addString((0, _cleanUrl.cleanURL)(attrs.oldURL, includeHashFragment)), addString((0, _cleanUrl.cleanURL)(attrs.newURL, includeHashFragment)), addString(attrs.customName), isInitialPage ? '' : isRouteChange ? 1 : 2, (0, _belSerializer.nullable)(isInitialPage && queueTime, _belSerializer.numeric, true) + (0, _belSerializer.nullable)(isInitialPage && appTime, _belSerializer.numeric, true) + (0, _belSerializer.nullable)(attrs.oldRoute, addString, true) + (0, _belSerializer.nullable)(attrs.newRoute, addString, true) + addString(attrs.id), addString(node.id), (0, _belSerializer.nullable)(attrs.firstPaint, _belSerializer.numeric, true) + (0, _belSerializer.nullable)(attrs.firstContentfulPaint, _belSerializer.numeric, false));
+          var attrParts = (0, _belSerializer.addCustomAttributes)(attrs.custom, addString);
+          children = children.concat(attrParts);
+          attrCount = attrParts.length;
+          if (apmAttributes) {
+            childCount++;
+            children.push('a,' + addString(apmAttributes));
+          }
+          break;
+        case 2:
+          fields.push(addString(params.method), (0, _belSerializer.numeric)(params.status), addString(params.host), addString(params.pathname), (0, _belSerializer.numeric)(metrics.txSize), (0, _belSerializer.numeric)(metrics.rxSize), attrs.isFetch ? 1 : attrs.isJSONP ? 2 : '', addString(node.id), (0, _belSerializer.nullable)(node.dt && node.dt.spanId, addString, true) + (0, _belSerializer.nullable)(node.dt && node.dt.traceId, addString, true) + (0, _belSerializer.nullable)(node.dt && node.dt.timestamp, _belSerializer.numeric, false));
+          break;
+        case 4:
+          var tracedTime = attrs.tracedTime;
+          fields.push(addString(attrs.name), (0, _belSerializer.nullable)(tracedTime, _belSerializer.numeric, true) + addString(node.id));
+          break;
+      }
+      for (var i = 0; i < node.children.length; i++) {
+        addNode(node.children[i], children);
+      }
+      fields.unshift((0, _belSerializer.numeric)(typeId), (0, _belSerializer.numeric)(childCount += attrCount));
+      nodeList.push(fields);
+      if (childCount) {
+        nodeList.push(children.join(';'));
+      }
+      if (hasNavTiming) {
+        // this build up the navTiming node
+        // it for each navTiming value (pre aggregated in nav-timing.js):
+        // we initialize the seperator to ',' (seperates the nodeType id from the first value)
+        // we initialize the navTiming node to 'b' (the nodeType id)
+        // if the value is present:
+        //   we add the seperator followed by the value
+        // otherwise
+        //   we add null seperator ('!') to the navTimingNode
+        //   we set the seperator to an empty string since we already wrote it above
+        //   the reason for writing the null seperator instead of setting the seperator
+        //   is to ensure we still write it if the null is the last navTiming value.
+
+        var seperator = ',';
+        var navTimingNode = 'b';
+        var prev = 0;
+
+        // get all navTiming values except navigationStart
+        // (since its the same as interaction.start)
+        // and limit to just the first 20 values we know about
+        (0, _mapOwn.mapOwn)(navTiming.slice(1, 21), function (i, v) {
+          if (v !== void 0) {
+            navTimingNode += seperator + (0, _belSerializer.numeric)(v - prev);
+            seperator = ',';
+            prev = v;
+          } else {
+            navTimingNode += seperator + '!';
+            seperator = '';
+          }
+        });
+        nodeList.push(navTimingNode);
+      } else if (typeId === 1) {
+        nodeList.push('');
+      }
+      return nodeList;
+    };
+    return addNode(root, []).join(';');
+  }
+}
+exports.Serializer = Serializer;

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

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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;
+const INTERACTION_EVENTS = ['click', 'submit', 'keypress', 'keydown', 'keyup', 'change'];
+exports.INTERACTION_EVENTS = INTERACTION_EVENTS;
+const MAX_TIMER_BUDGET = 999;
+exports.MAX_TIMER_BUDGET = MAX_TIMER_BUDGET;
+const FN_START = 'fn-start';
+exports.FN_START = FN_START;
+const FN_END = 'fn-end';
+exports.FN_END = FN_END;
+const CB_START = 'cb-start';
+exports.CB_START = CB_START;
+const INTERACTION_API = 'api-ixn-';
+exports.INTERACTION_API = INTERACTION_API;
+const REMAINING = 'remaining';
+exports.REMAINING = REMAINING;
+const INTERACTION = 'interaction';
+exports.INTERACTION = INTERACTION;
+const SPA_NODE = 'spaNode';
+exports.SPA_NODE = SPA_NODE;
+const JSONP_NODE = 'jsonpNode';
+exports.JSONP_NODE = JSONP_NODE;
+const FETCH_START = 'fetch-start';
+exports.FETCH_START = FETCH_START;
+const FETCH_DONE = 'fetch-done';
+exports.FETCH_DONE = FETCH_DONE;
+const FETCH_BODY = 'fetch-body-';
+exports.FETCH_BODY = FETCH_BODY;
+const JSONP_END = 'jsonp-end';
+exports.JSONP_END = JSONP_END;
+const originalSetTimeout = _config.originals.ST;
+exports.originalSetTimeout = originalSetTimeout;
+const START = '-start';
+exports.START = START;
+const END = '-end';
+exports.END = END;
+const BODY = '-body';
+exports.BODY = BODY;
+const CB_END = 'cb' + END;
+exports.CB_END = CB_END;
+const JS_TIME = 'jsTime';
+exports.JS_TIME = JS_TIME;
+const FETCH = 'fetch';
+exports.FETCH = FETCH;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Spa", {
+  enumerable: true,
+  get: function () {
+    return _index.Instrument;
+  }
+});
+var _index = require("./instrument/index");

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

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Instrument = void 0;
+var _wrap = require("../../../common/wrap");
+var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
+var _instrumentBase = require("../../utils/instrument-base");
+var _config = require("../../../common/config/config");
+var _now = require("../../../common/timing/now");
+var CONSTANTS = _interopRequireWildcard(require("../constants"));
+var _globalScope = require("../../../common/util/global-scope");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+*/
+
+const {
+  FEATURE_NAME,
+  START,
+  END,
+  BODY,
+  CB_END,
+  JS_TIME,
+  FETCH,
+  FN_START,
+  CB_START,
+  FN_END
+} = CONSTANTS;
+class Instrument extends _instrumentBase.InstrumentBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    if (!_globalScope.isBrowserScope) return; // SPA not supported outside web env
+
+    if (!(0, _config.getRuntime)(agentIdentifier).xhrWrappable) return;
+    try {
+      this.removeOnAbort = new AbortController();
+    } catch (e) {}
+    let depth = 0;
+    let startHash;
+    const tracerEE = this.ee.get('tracer');
+    const jsonpEE = (0, _wrap.wrapJsonP)(this.ee);
+    const promiseEE = (0, _wrap.wrapPromise)(this.ee);
+    const timerEE = (0, _wrap.wrapTimer)(this.ee);
+    const xhrEE = (0, _wrap.wrapXhr)(this.ee);
+    const eventsEE = this.ee.get('events'); // wrapXhr will call wrapEvents
+    const fetchEE = (0, _wrap.wrapFetch)(this.ee);
+    const historyEE = (0, _wrap.wrapHistory)(this.ee);
+    const mutationEE = (0, _wrap.wrapMutation)(this.ee);
+    this.ee.on(FN_START, startTimestamp);
+    promiseEE.on(CB_START, startTimestamp);
+    jsonpEE.on(CB_START, startTimestamp);
+    this.ee.on(FN_END, endTimestamp);
+    promiseEE.on(CB_END, endTimestamp);
+    jsonpEE.on(CB_END, endTimestamp);
+    this.ee.buffer([FN_START, FN_END, 'xhr-resolved'], this.featureName);
+    eventsEE.buffer([FN_START], this.featureName);
+    timerEE.buffer(['setTimeout' + END, 'clearTimeout' + START, FN_START], this.featureName);
+    xhrEE.buffer([FN_START, 'new-xhr', 'send-xhr' + START], this.featureName);
+    fetchEE.buffer([FETCH + START, FETCH + '-done', FETCH + BODY + START, FETCH + BODY + END], this.featureName);
+    historyEE.buffer(['newURL'], this.featureName);
+    mutationEE.buffer([FN_START], this.featureName);
+    promiseEE.buffer(['propagate', CB_START, CB_END, 'executor-err', 'resolve' + START], this.featureName);
+    tracerEE.buffer([FN_START, 'no-' + FN_START], this.featureName);
+    jsonpEE.buffer(['new-jsonp', 'cb-start', 'jsonp-error', 'jsonp-end'], this.featureName);
+    timestamp(fetchEE, FETCH + START);
+    timestamp(fetchEE, FETCH + '-done');
+    timestamp(jsonpEE, 'new-jsonp');
+    timestamp(jsonpEE, 'jsonp-end');
+    timestamp(jsonpEE, 'cb-start');
+    historyEE.on('pushState-end', trackURLChange);
+    historyEE.on('replaceState-end', trackURLChange);
+    window.addEventListener('hashchange', trackURLChange, (0, _eventListenerOpts.eventListenerOpts)(true, this.removeOnAbort?.signal));
+    window.addEventListener('load', trackURLChange, (0, _eventListenerOpts.eventListenerOpts)(true, this.removeOnAbort?.signal));
+    window.addEventListener('popstate', function () {
+      trackURLChange(0, depth > 1);
+    }, (0, _eventListenerOpts.eventListenerOpts)(true, this.removeOnAbort?.signal));
+    function trackURLChange(unusedArgs, hashChangedDuringCb) {
+      historyEE.emit('newURL', ['' + window.location, hashChangedDuringCb]);
+    }
+    function startTimestamp() {
+      depth++;
+      startHash = window.location.hash;
+      this[FN_START] = (0, _now.now)();
+    }
+    function endTimestamp() {
+      depth--;
+      if (window.location.hash !== startHash) {
+        trackURLChange(0, true);
+      }
+      var time = (0, _now.now)();
+      this[JS_TIME] = ~~this[JS_TIME] + time - this[FN_START];
+      this[FN_END] = time;
+    }
+    function timestamp(ee, type) {
+      ee.on(type, function () {
+        this[type] = (0, _now.now)();
+      });
+    }
+    this.abortHandler = this.#abort;
+    this.importAggregator();
+  }
+
+  /** Restoration and resource release tasks to be done if SPA loader is being aborted. Unwind changes to globals and subscription to DOM events. */
+  #abort() {
+    this.removeOnAbort?.abort();
+    this.abortHandler = undefined; // weakly allow this abort op to run only once
+  }
+}
+exports.Instrument = Instrument;

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AggregateBase = void 0;
+var _featureBase = require("./feature-base");
+class AggregateBase extends _featureBase.FeatureBase {
+  constructor(agentIdentifier, aggregator, featureName) {
+    super(agentIdentifier, aggregator, featureName);
+  }
+}
+exports.AggregateBase = AggregateBase;

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

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FeatureBase = void 0;
+var _config = require("../../common/config/config");
+var _contextualEe = require("../../common/event-emitter/contextual-ee");
+var _configure = require("../../loaders/configure/configure");
+var _nreum = require("../../common/window/nreum");
+class FeatureBase {
+  constructor(agentIdentifier, aggregator, featureName) {
+    /** @type {string} */
+    this.agentIdentifier = agentIdentifier;
+    /** @type {Aggregator} */
+    this.aggregator = aggregator;
+    /** @type {ContextualEE} */
+    this.ee = _contextualEe.ee.get(agentIdentifier, (0, _config.getRuntime)(this.agentIdentifier).isolatedBacklog);
+    /** @type {string} */
+    this.featureName = featureName;
+    /**
+     * Blocked can be used to prevent aggregation and harvest after inititalization time of the feature.
+     * This can currently happen if RUM response setToken flag is 0, which is tied to ingest account entitlement info.
+     * @type {boolean}
+     */
+    this.blocked = false;
+    this.checkConfiguration();
+  }
+
+  /**
+   * Checks for additional `jsAttributes` items to support backward compatibility with implementations of the agent where
+   * loader configurations may appear after the loader code is executed.
+   */
+  checkConfiguration() {
+    // NOTE: This check has to happen at aggregator load time, but could be moved to `AggregateBase`.
+    if (!(0, _config.isConfigured)(this.agentIdentifier)) {
+      let jsAttributes = {
+        ...(0, _nreum.gosCDN)().info?.jsAttributes
+      };
+      try {
+        jsAttributes = {
+          ...jsAttributes,
+          ...(0, _config.getInfo)(this.agentIdentifier)?.jsAttributes
+        };
+      } catch (err) {
+        // do nothing
+      }
+      (0, _configure.configure)(this.agentIdentifier, {
+        ...(0, _nreum.gosCDN)(),
+        info: {
+          ...(0, _nreum.gosCDN)().info,
+          jsAttributes
+        }
+      });
+    }
+  }
+}
+exports.FeatureBase = FeatureBase;

package/dist/cjs/features/utils/handler-cache.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HandlerCache = void 0;
+/**
+ * A class to defer callback execution until a decision can be reached
+ */
+class HandlerCache {
+  /** @private @type {boolean | undefined} */
+  #decision = undefined;
+  /** @private @type {boolean} */
+  #shouldsettle = true;
+  /** @private @type {Function[]} */
+  #cache = [];
+  /** @private @type {Timeout} */
+  #settleTimer = setTimeout(() => this.#close(), 5000);
+
+  /**
+     * tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
+     * and execute all the storage callbacks saved up in the handlerCache
+     * @private
+     */
+  #drain() {
+    this.#cache.forEach(h => h());
+    this.#cache = [];
+    clearTimeout(this.#settleTimer);
+  }
+
+  /**
+     * tell the handlerCache not to execute any of the storage callbacks
+     * and wipe out all the storage callbacks saved up in the handlerCache
+     * @private
+     */
+  #close() {
+    this.#shouldsettle = false;
+    this.#cache = [];
+  }
+
+  /**
+     * Wrap callback functions with this method to defer their execution until a decision has been reached
+     * @param {Function} handler
+     * @returns {void}
+     */
+  settle(handler) {
+    if (this.#decision === false || this.#shouldsettle === false) return;else if (this.#decision === undefined) this.#cache.push(handler);else handler();
+  }
+
+  /**
+     * Make a decision about what to do with the cache of callbacks.
+     * --- if true: tell the handlerCache that its ok to immediately execute the callbacks that are triggered by the ee from this moment on
+     * and execute all the storage callbacks saved up in the handlerCache ---
+     * --- if false: tell the handlerCache not to execute any of the storage callbacks
+     * and wipe out all the storage callbacks saved up in the handlerCache
+     * @param {boolean} decision
+     */
+  decide(decision) {
+    this.#decision = decision;
+    if (decision === false) this.#close();
+    if (decision === true) this.#drain();
+  }
+}
+exports.HandlerCache = HandlerCache;