@newrelic/browser-agent 0.0.9 → 0.1.229

package/dist/cjs/features/page_view_timing/long-tasks.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onLongTask = void 0;
+var _eol = require("../../common/unload/eol");
+/**
+ * Calls the `onReport` function for every entry reported by the PerformanceLongTaskTiming API.
+ * The reported value is a `DOMHighResTimeStamp`.
+ *
+ * The callback is always called when the page's visibility state changes to hidden.
+ * As a result, the `onReport` function might be called multiple times during the same page load.
+ *
+ * @param {Function} onReport - callback that accepts a `metric` object as the single parameter
+ */
+const onLongTask = onReport => {
+  const handleEntries = entries => {
+    entries.forEach(entry => {
+      const metric = {
+        name: 'LT',
+        value: entry.duration,
+        info: {
+          // this property deviates from CWV std interface but will hold the custom context to send to NRDB
+          ltFrame: entry.name,
+          // MDN: the browsing context or frame that can be attributed to the long task
+          ltStart: entry.startTime,
+          // MDN: a double representing the time (millisec) when the task started
+          ltCtr: entry.attribution[0].containerType // MDN: type of frame container: 'iframe', 'embed', or 'object' ... but this can also be 'window'
+        }
+      };
+
+      if (metric.info.ltCtr !== 'window') {
+        // the following properties are only of relevance & appended for html elements
+        Object.assign(metric.info, {
+          ltCtrSrc: entry.attribution[0].containerSrc,
+          // MDN: container's 'src' attribute
+          ltCtrId: entry.attribution[0].containerId,
+          // MDN: container's 'id' attribute
+          ltCtrName: entry.attribution[0].containerName // MDN: container's 'name' attribute
+        });
+      }
+
+      onReport(metric); // report every long task observed unconditionally
+    });
+  };
+
+  let observer;
+  try {
+    if (PerformanceObserver.supportedEntryTypes.includes('longtask')) {
+      observer = new PerformanceObserver(list => {
+        // Delay by a microtask to workaround a bug in Safari where the
+        // callback is invoked immediately, rather than in a separate task.
+        // See: https://github.com/GoogleChrome/web-vitals/issues/277
+        Promise.resolve().then(() => {
+          handleEntries(list.getEntries());
+        });
+      });
+      observer.observe({
+        type: 'longtask',
+        buffered: true
+      });
+    }
+  } catch (e) {
+    // Do nothing.
+  }
+  if (observer) {
+    (0, _eol.subscribeToEOL)(() => {
+      handleEntries(observer.takeRecords());
+    }, true); // this bool is a temp arg under staged BFCache work that runs the func under the new page session logic -- tb removed w/ the feature flag later
+
+    /* No work needed on BFCache restore for long task. */
+  }
+};
+exports.onLongTask = onLongTask;

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

@@ -0,0 +1,375 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Aggregate = void 0;
+var _registerHandler = require("../../../common/event-emitter/register-handler");
+var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
+var _mapOwn = require("../../../common/util/map-own");
+var _reduce = require("../../../common/util/reduce");
+var _stringify = require("../../../common/util/stringify");
+var _parseUrl = require("../../../common/url/parse-url");
+var _supportsPerformanceObserver = require("../../../common/window/supports-performance-observer");
+var _lodash = _interopRequireDefault(require("lodash._slice"));
+var _config = require("../../../common/config/config");
+var _now = require("../../../common/timing/now");
+var _aggregateBase = require("../../utils/aggregate-base");
+var _constants = require("../constants");
+var _drain = require("../../../common/drain/drain");
+var _handlerCache = require("../../utils/handler-cache");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+class Aggregate extends _aggregateBase.AggregateBase {
+  static featureName = _constants.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
+
+    // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
+    if (!(0, _config.getRuntime)(agentIdentifier).xhrWrappable) return;
+    const handlerCache = new _handlerCache.HandlerCache();
+    this.ptid = '';
+    this.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
+      }
+    };
+    this.toAggregate = {
+      typing: [1000, 2000],
+      scrolling: [100, 1000],
+      mousing: [1000, 2000],
+      touching: [1000, 2000]
+    };
+    this.rename = {
+      typing: {
+        keydown: true,
+        keyup: true,
+        keypress: true
+      },
+      mousing: {
+        mousemove: true,
+        mouseenter: true,
+        mouseleave: true,
+        mouseover: true,
+        mouseout: true
+      },
+      scrolling: {
+        scroll: true
+      },
+      touching: {
+        touchstart: true,
+        touchmove: true,
+        touchend: true,
+        touchcancel: true,
+        touchenter: true,
+        touchleave: true
+      }
+    };
+    this.trace = {};
+    this.nodeCount = 0;
+    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;
+    (0, _registerHandler.registerHandler)('feat-stn', () => {
+      this.storeTiming(window.performance.timing);
+      var 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
+
+      function onHarvestFinished(result) {
+        // start timer only if ptid was returned by server
+        if (result.sent && result.responseText && !this.ptid) {
+          this.ptid = result.responseText;
+          (0, _config.getRuntime)(this.agentIdentifier).ptid = this.ptid;
+          scheduler.startTimer(this.harvestTimeSeconds);
+        }
+        if (result.sent && result.retry && this.sentTrace) {
+          (0, _mapOwn.mapOwn)(this.sentTrace, (name, nodes) => {
+            this.mergeSTNs(name, nodes);
+          });
+          this.sentTrace = null;
+        }
+      }
+      function prepareHarvest(options) {
+        if ((0, _now.now)() > 15 * 60 * 1000) {
+          // been collecting for over 15 min, empty trace object and bail
+          scheduler.stopTimer();
+          this.trace = {};
+          return;
+        }
+
+        // only send when there are more than 30 nodes to send
+        if (this.ptid && this.nodeCount <= 30) return;
+        return this.takeSTNs(options.retry);
+      }
+      handlerCache.decide(true);
+    }, this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('block-stn', () => {
+      handlerCache.decide(false);
+    }, this.featureName, this.ee);
+
+    // register the handlers immediately... but let the handlerCache decide if the data should actually get stored...
+    (0, _registerHandler.registerHandler)('bst', (...args) => handlerCache.settle(() => this.storeEvent(...args)), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('bstTimer', (...args) => handlerCache.settle(() => this.storeTimer(...args)), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('bstResource', (...args) => handlerCache.settle(() => this.storeResources(...args)), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('bstHist', (...args) => handlerCache.settle(() => this.storeHist(...args)), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('bstXhrAgg', (...args) => handlerCache.settle(() => this.storeXhrAgg(...args)), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('bstApi', (...args) => handlerCache.settle(() => this.storeSTN(...args)), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('errorAgg', (...args) => handlerCache.settle(() => this.storeErrorAgg(...args)), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('pvtAdded', (...args) => handlerCache.settle(() => this.processPVT(...args)), this.featureName, this.ee);
+    (0, _drain.drain)(this.agentIdentifier, this.featureName);
+  }
+  processPVT(name, value, attrs) {
+    var t = {};
+    t[name] = value;
+    this.storeTiming(t, true);
+    if (this.hasFID(name, attrs)) this.storeEvent({
+      type: 'fid',
+      target: 'document'
+    }, 'document', value, value + attrs.fid);
+  }
+  storeTiming(_t, ignoreOffset) {
+    var key;
+    var val;
+    var timeOffset;
+    var dateNow = Date.now();
+
+    // loop iterates through prototype also (for FF)
+    for (key in _t) {
+      val = _t[key];
+
+      // 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 && val < dateNow)) continue;
+      timeOffset = !ignoreOffset ? _t[key] - (0, _config.getRuntime)(this.agentIdentifier).offset : _t[key];
+      this.storeSTN({
+        n: key,
+        s: timeOffset,
+        e: timeOffset,
+        o: 'document',
+        t: 'timing'
+      });
+    }
+  }
+  storeTimer(target, start, end, type) {
+    var category = 'timer';
+    if (type === 'requestAnimationFrame') category = type;
+    var evt = {
+      n: type,
+      s: start,
+      e: end,
+      o: 'window',
+      t: category
+    };
+    this.storeSTN(evt);
+  }
+  storeEvent(currentEvent, target, start, end) {
+    if (this.shouldIgnoreEvent(currentEvent, target)) return false;
+    var evt = {
+      n: this.evtName(currentEvent.type),
+      s: start,
+      e: end,
+      t: '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);
+  }
+  evtName(type) {
+    var name = type;
+    (0, _mapOwn.mapOwn)(this.rename, function (key, val) {
+      if (type in val) name = key;
+    });
+    return name;
+  }
+  evtOrigin(t, target) {
+    var origin = 'unknown';
+    if (t && t instanceof XMLHttpRequest) {
+      var params = this.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) origin += '.' + (0, _lodash.default)(t.classList).join('.');
+    }
+    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;
+  }
+  storeHist(path, old, time) {
+    var node = {
+      n: 'history.pushState',
+      s: time,
+      e: time,
+      o: path,
+      t: old
+    };
+    this.storeSTN(node);
+  }
+  storeResources(resources) {
+    if (!resources || resources.length === 0) return;
+    resources.forEach(currentResource => {
+      var parsed = (0, _parseUrl.parseUrl)(currentResource.name);
+      var res = {
+        n: currentResource.initiatorType,
+        s: currentResource.fetchStart | 0,
+        e: currentResource.responseEnd | 0,
+        o: parsed.protocol + '://' + parsed.hostname + ':' + parsed.port + parsed.pathname,
+        // resource.name is actually a URL so it's the source
+        t: currentResource.entryType
+      };
+
+      // don't recollect old resources
+      if (res.s <= this.laststart) return;
+      this.storeSTN(res);
+    });
+    this.laststart = resources[resources.length - 1].fetchStart | 0;
+  }
+  storeErrorAgg(type, name, params, metrics) {
+    if (type !== 'err') return;
+    var node = {
+      n: 'error',
+      s: metrics.time,
+      e: metrics.time,
+      o: params.message,
+      t: params.stackHash
+    };
+    this.storeSTN(node);
+  }
+  storeXhrAgg(type, name, params, metrics) {
+    if (type !== 'xhr') return;
+    var node = {
+      n: 'Ajax',
+      s: metrics.time,
+      e: metrics.time + metrics.duration,
+      o: params.status + ' ' + params.method + ': ' + params.host + params.pathname,
+      t: 'ajax'
+    };
+    this.storeSTN(node);
+  }
+  storeSTN(stn) {
+    // limit the number of data that is stored
+    if (this.nodeCount >= this.maxNodesPerHarvest) return;
+    var traceArr = this.trace[stn.n];
+    if (!traceArr) traceArr = this.trace[stn.n] = [];
+    traceArr.push(stn);
+    this.nodeCount++;
+  }
+  mergeSTNs(key, nodes) {
+    // limit the number of data that is stored
+    if (this.nodeCount >= this.maxNodesPerHarvest) return;
+    var traceArr = this.trace[key];
+    if (!traceArr) traceArr = this.trace[key] = [];
+    this.trace[key] = nodes.concat(traceArr);
+    this.nodeCount += nodes.length;
+  }
+  takeSTNs(retry) {
+    // if the observer is not being used, this checks resourcetiming buffer every harvest
+    if (!(0, _supportsPerformanceObserver.supportsPerformanceObserver)()) {
+      this.storeResources(window.performance.getEntriesByType('resource'));
+    }
+    var stns = (0, _reduce.reduce)((0, _mapOwn.mapOwn)(this.trace, (name, nodes) => {
+      if (!(name in this.toAggregate)) return nodes;
+      return (0, _reduce.reduce)((0, _mapOwn.mapOwn)((0, _reduce.reduce)(nodes.sort(this.byStart), this.smearEvtsByOrigin(name), {}), this.val), this.flatten, []);
+    }), this.flatten, []);
+    if (stns.length === 0) return {};
+    if (retry) {
+      this.sentTrace = this.trace;
+    }
+    this.trace = {};
+    this.nodeCount = 0;
+    var stnInfo = {
+      qs: {
+        st: '' + (0, _config.getRuntime)(this.agentIdentifier).offset
+      },
+      body: {
+        res: stns
+      }
+    };
+    if (!this.ptid) {
+      const {
+        userAttributes,
+        atts,
+        jsAttributes
+      } = (0, _config.getInfo)(this.agentIdentifier);
+      stnInfo.qs.ua = userAttributes;
+      stnInfo.qs.at = atts;
+      var ja = (0, _stringify.stringify)(jsAttributes);
+      stnInfo.qs.ja = ja === '{}' ? null : ja;
+    }
+    return stnInfo;
+  }
+  byStart(a, b) {
+    return a.s - b.s;
+  }
+  smearEvtsByOrigin(name) {
+    var maxGap = this.toAggregate[name][0];
+    var maxLen = this.toAggregate[name][1];
+    var lastO = {};
+    return (byOrigin, evt) => {
+      var lastArr = byOrigin[evt.o];
+      lastArr || (lastArr = byOrigin[evt.o] = []);
+      var last = lastO[evt.o];
+      if (name === 'scrolling' && !this.trivial(evt)) {
+        lastO[evt.o] = null;
+        evt.n = 'scroll';
+        lastArr.push(evt);
+      } else if (last && evt.s - last.s < maxLen && last.e > evt.s - maxGap) {
+        last.e = evt.e;
+      } else {
+        lastO[evt.o] = evt;
+        lastArr.push(evt);
+      }
+      return byOrigin;
+    };
+  }
+  val(key, value) {
+    return value;
+  }
+  flatten(a, b) {
+    return a.concat(b);
+  }
+  hasFID(name, attrs) {
+    return name === 'fi' && !!attrs && typeof attrs.fid === 'number';
+  }
+  trivial(node) {
+    var limit = 4;
+    if (node && typeof node.e === 'number' && typeof node.s === 'number' && node.e - node.s < limit) return true;else return false;
+  }
+  shouldIgnoreEvent(event, target) {
+    var origin = this.evtOrigin(event.target, target);
+    if (event.type in this.ignoredEvents.global) return true;
+    if (!!this.ignoredEvents[origin] && this.ignoredEvents[origin].ignoreAll) return true;
+    if (!!this.ignoredEvents[origin] && event.type in this.ignoredEvents[origin]) return true;
+    return false;
+  }
+}
+exports.Aggregate = Aggregate;

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

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.START = exports.RESOURCE_TIMING_BUFFER_FULL = exports.RESOURCE = exports.PUSH_STATE = exports.ORIG_EVENT = exports.FN_START = exports.FN_END = exports.FEATURE_NAME = exports.END = exports.BST_TIMER = exports.BST_RESOURCE = exports.ADD_EVENT_LISTENER = void 0;
+var _config = require("../../common/config/config");
+var _features = require("../../loaders/features/features");
+const FEATURE_NAME = _features.FEATURE_NAMES.sessionTrace;
+exports.FEATURE_NAME = FEATURE_NAME;
+const RESOURCE_TIMING_BUFFER_FULL = 'resourcetimingbufferfull';
+exports.RESOURCE_TIMING_BUFFER_FULL = RESOURCE_TIMING_BUFFER_FULL;
+const BST_RESOURCE = 'bstResource';
+exports.BST_RESOURCE = BST_RESOURCE;
+const RESOURCE = 'resource';
+exports.RESOURCE = RESOURCE;
+const START = '-start';
+exports.START = START;
+const END = '-end';
+exports.END = END;
+const FN_START = 'fn' + START;
+exports.FN_START = FN_START;
+const FN_END = 'fn' + END;
+exports.FN_END = FN_END;
+const BST_TIMER = 'bstTimer';
+exports.BST_TIMER = BST_TIMER;
+const PUSH_STATE = 'pushState';
+exports.PUSH_STATE = PUSH_STATE;
+const ORIG_EVENT = _config.originals.EV;
+exports.ORIG_EVENT = ORIG_EVENT;
+const ADD_EVENT_LISTENER = 'addEventListener';
+exports.ADD_EVENT_LISTENER = ADD_EVENT_LISTENER;

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

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

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

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Instrument = void 0;
+var _handle = require("../../../common/event-emitter/handle");
+var _wrap = require("../../../common/wrap");
+var _supportsPerformanceObserver = require("../../../common/window/supports-performance-observer");
+var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
+var _now = require("../../../common/timing/now");
+var _instrumentBase = require("../../utils/instrument-base");
+var CONSTANTS = _interopRequireWildcard(require("../constants"));
+var _features = require("../../../loaders/features/features");
+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 {
+  BST_RESOURCE,
+  BST_TIMER,
+  END,
+  FEATURE_NAME,
+  FN_END,
+  FN_START,
+  ADD_EVENT_LISTENER,
+  PUSH_STATE,
+  RESOURCE,
+  RESOURCE_TIMING_BUFFER_FULL,
+  START,
+  ORIG_EVENT: origEvent
+} = CONSTANTS;
+const CRT = 'clearResourceTimings';
+class Instrument extends _instrumentBase.InstrumentBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    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);
+    (0, _wrap.wrapEvents)(thisInstrumentEE);
+    thisInstrumentEE.on(FN_START, function (args, target) {
+      var evt = args[0];
+      if (evt instanceof origEvent) {
+        this.bstStart = (0, _now.now)();
+      }
+    });
+    thisInstrumentEE.on(FN_END, function (args, target) {
+      var evt = args[0];
+      if (evt instanceof origEvent) {
+        // ISSUE: when target is XMLHttpRequest, nr@context should have params so we can calculate event origin
+        // When ajax is disabled, this may fail without making ajax a dependency of session_trace
+        (0, _handle.handle)('bst', [evt, 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;
+    });
+    thisInstrumentEE.on(PUSH_STATE + END, function (args) {
+      (0, _handle.handle)('bstHist', [location.pathname + location.hash, this.startPath, this.time], undefined, _features.FEATURE_NAMES.sessionTrace, thisInstrumentEE);
+    });
+    if ((0, _supportsPerformanceObserver.supportsPerformanceObserver)()) {
+      // capture initial resources, in case our observer missed anything
+      (0, _handle.handle)(BST_RESOURCE, [window.performance.getEntriesByType('resource')], undefined, _features.FEATURE_NAMES.sessionTrace, thisInstrumentEE);
+      observeResourceTimings();
+    } else {
+      // collect resource timings once when buffer is full
+      if (window.performance[CRT] && window.performance[ADD_EVENT_LISTENER]) {
+        window.performance.addEventListener(RESOURCE_TIMING_BUFFER_FULL, this.onResourceTimingBufferFull, (0, _eventListenerOpts.eventListenerOpts)(false));
+      }
+    }
+    function observeResourceTimings() {
+      var observer = new PerformanceObserver((list, observer) => {
+        // eslint-disable-line no-undef
+        var entries = list.getEntries();
+        (0, _handle.handle)(BST_RESOURCE, [entries], undefined, _features.FEATURE_NAMES.sessionTrace, thisInstrumentEE);
+      });
+      try {
+        observer.observe({
+          entryTypes: ['resource']
+        });
+      } catch (e) {
+        // do nothing
+      }
+    }
+    document.addEventListener('scroll', this.noOp, (0, _eventListenerOpts.eventListenerOpts)(false));
+    document.addEventListener('keypress', this.noOp, (0, _eventListenerOpts.eventListenerOpts)(false));
+    document.addEventListener('click', this.noOp, (0, _eventListenerOpts.eventListenerOpts)(false));
+    this.abortHandler = this.#abort;
+    this.importAggregator();
+  }
+
+  /** Restoration and resource release tasks to be done if Session trace loader is being aborted. Unwind changes to globals. */
+  #abort() {
+    window.performance.removeEventListener(RESOURCE_TIMING_BUFFER_FULL, this.onResourceTimingBufferFull, false);
+    // The doc interaction noOp listeners are harmless--cannot buffer data into EE.
+    this.abortHandler = undefined; // weakly allow this abort op to run only once
+  }
+
+  noOp(e) {/* no-op */}
+  onResourceTimingBufferFull(evt) {
+    (0, _handle.handle)(BST_RESOURCE, [window.performance.getEntriesByType(RESOURCE)], undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
+
+    // stop recording once buffer is full
+    if (window.performance[CRT]) {
+      try {
+        window.performance.removeEventListener(RESOURCE_TIMING_BUFFER_FULL, this.onResourceTimingBufferFull, false);
+      } catch (e) {}
+    }
+  }
+}
+exports.Instrument = Instrument;