@newrelic/browser-agent 0.0.9 → 0.1.229

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

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { handle } from '../../../common/event-emitter/handle';
+import { now } from '../../../common/timing/now';
+import { getOrSet } from '../../../common/util/get-or-set';
+import { wrapRaf, wrapTimer, wrapEvents, wrapXhr } from '../../../common/wrap';
+import slice from 'lodash._slice';
+import './debug';
+import { InstrumentBase } from '../../utils/instrument-base';
+import { FEATURE_NAME, NR_ERR_PROP } from '../constants';
+import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { globalScope } from '../../../common/util/global-scope';
+import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts';
+import { getRuntime } from '../../../common/config/config';
+import { stringify } from '../../../common/util/stringify';
+export class Instrument extends InstrumentBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    // skipNext counter to keep track of uncaught
+    // errors that will be the same as caught errors.
+    this.skipNext = 0;
+    this.origOnerror = globalScope.onerror;
+    try {
+      this.removeOnAbort = new AbortController();
+    } // this try-catch can be removed when IE11 is completely unsupported & gone
+    catch (e) {}
+    const thisInstrument = this;
+    thisInstrument.ee.on('fn-start', function (args, obj, methodName) {
+      if (thisInstrument.abortHandler) thisInstrument.skipNext += 1;
+    });
+    thisInstrument.ee.on('fn-err', function (args, obj, err) {
+      if (thisInstrument.abortHandler && !err[NR_ERR_PROP]) {
+        getOrSet(err, NR_ERR_PROP, function getVal() {
+          return true;
+        });
+        this.thrown = true;
+        notice(err, undefined, thisInstrument.ee);
+      }
+    });
+    thisInstrument.ee.on('fn-end', function () {
+      if (!thisInstrument.abortHandler) return;
+      if (!this.thrown && thisInstrument.skipNext > 0) thisInstrument.skipNext -= 1;
+    });
+    thisInstrument.ee.on('internal-error', function (e) {
+      handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, thisInstrument.ee);
+    });
+
+    // Tack on our error handler onto the existing global one.
+    globalScope.onerror = (...args) => {
+      if (this.origOnerror) this.origOnerror(...args);
+      this.onerrorHandler(...args);
+      return false;
+    };
+    globalScope.addEventListener('unhandledrejection', e => {
+      /** rejections can contain data of any type -- this is an effort to keep the message human readable */
+      const err = castReasonToError(e.reason);
+      handle('err', [err, now(), false, {
+        unhandledPromiseRejection: 1
+      }], undefined, FEATURE_NAMES.jserrors, this.ee);
+    }, eventListenerOpts(false, this.removeOnAbort?.signal));
+    wrapRaf(this.ee);
+    wrapTimer(this.ee);
+    wrapEvents(this.ee);
+    if (getRuntime(agentIdentifier).xhrWrappable) wrapXhr(this.ee);
+    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();
+  }
+
+  /** Restoration and resource release tasks to be done if JS error loader is being aborted. Unwind changes to globals. */
+  #abort() {
+    this.removeOnAbort?.abort();
+    this.abortHandler = undefined; // weakly allow this abort op to run only once
+  }
+
+  /**
+   * FF and Android browsers do not provide error info to the 'error' event callback,
+   * so we must use window.onerror
+   * @param {string} message
+   * @param {string} filename
+   * @param {number} lineno
+   * @param {number} column
+   * @param {Error | *} errorObj
+   * @returns
+   */
+  onerrorHandler(message, filename, lineno, column, errorObj) {
+    try {
+      if (this.skipNext) this.skipNext -= 1;else notice(errorObj || new UncaughtException(message, filename, lineno), true, this.ee);
+    } catch (e) {
+      try {
+        handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, this.ee);
+      } catch (err) {
+        // do nothing
+      }
+    }
+    if (typeof this.origOnerror === 'function') return this.origOnerror.apply(this, slice(arguments));
+    return false;
+  }
+}
+
+/**
+ *
+ * @param {string} message
+ * @param {string} filename
+ * @param {number} lineno
+ */
+function UncaughtException(message, filename, lineno) {
+  this.message = message || 'Uncaught error with no additional information';
+  this.sourceURL = filename;
+  this.line = lineno;
+}
+
+/**
+ * Adds a timestamp and emits the 'err' event, which the error aggregator listens for
+ * @param {Error} err
+ * @param {boolean} doNotStamp
+ * @param {ContextualEE} ee
+ */
+function notice(err, doNotStamp, ee) {
+  // by default add timestamp, unless specifically told not to
+  // this is to preserve existing behavior
+  var time = !doNotStamp ? now() : null;
+  handle('err', [err, time], undefined, FEATURE_NAMES.jserrors, ee);
+}
+
+/**
+ * Attempts to cast an unhandledPromiseRejection reason (reject(...)) to an Error object
+ * @param {*} reason - The reason property from an unhandled promise rejection
+ * @returns {Error} - An Error object with the message as the casted reason
+ */
+function castReasonToError(reason) {
+  let prefix = 'Unhandled Promise Rejection: ';
+  if (reason instanceof Error) {
+    try {
+      reason.message = prefix + reason.message;
+      return reason;
+    } catch (e) {
+      return reason;
+    }
+  }
+  if (typeof reason === 'undefined') return new Error(prefix);
+  try {
+    return new Error(prefix + stringify(reason));
+  } catch (err) {
+    return new Error(prefix);
+  }
+}

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

@@ -0,0 +1,129 @@
+import { getRuntime } from '../../../common/config/config';
+import { registerHandler } from '../../../common/event-emitter/register-handler';
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
+import { AggregateBase } from '../../utils/aggregate-base';
+import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL } from '../constants';
+import { drain } from '../../../common/drain/drain';
+import { getFrameworks } from '../../../common/metrics/framework-detection';
+import { protocol } from '../../../common/url/protocol';
+import { getRules, validateRules } from '../../../common/util/obfuscate';
+import { VERSION } from '../../../common/constants/environment-variables';
+import { onDOMContentLoaded } from '../../../common/window/load';
+import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
+import { isBrowserScope } from '../../../common/util/global-scope';
+export class Aggregate extends AggregateBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, FEATURE_NAME);
+    let scheduler;
+
+    // If RUM-call's response determines that customer lacks entitlements for the /jserror ingest endpoint, don't harvest at all.
+    registerHandler('block-err', () => {
+      this.blocked = true;
+      if (scheduler) scheduler.aborted = true; // RUM response may or may not have happened already before scheduler initialization below
+    }, this.featureName, this.ee);
+
+    // Allow features external to the metrics feature to capture SMs and CMs through the event emitter
+    registerHandler(SUPPORTABILITY_METRIC_CHANNEL, this.storeSupportabilityMetrics.bind(this), this.featureName, this.ee);
+    registerHandler(CUSTOM_METRIC_CHANNEL, this.storeEventMetrics.bind(this), this.featureName, this.ee);
+    this.singleChecks(); // checks that are run only one time, at script load
+    this.eachSessionChecks(); // the start of every time user engages with page
+
+    // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
+    scheduler = new HarvestScheduler('jserrors', {
+      onUnload: () => this.unload()
+    }, this);
+    scheduler.harvest.on('jserrors', () => ({
+      body: this.aggregator.take(['cm', 'sm'])
+    }));
+    drain(this.agentIdentifier, this.featureName); // regardless if this is blocked or not, drain is needed to unblock other features from harvesting (counteract registerDrain)
+  }
+
+  storeSupportabilityMetrics(name, value) {
+    if (this.blocked) return;
+    const type = SUPPORTABILITY_METRIC;
+    const params = {
+      name
+    };
+    this.aggregator.storeMetric(type, name, params, value);
+  }
+  storeEventMetrics(name, metrics) {
+    if (this.blocked) return;
+    const type = CUSTOM_METRIC;
+    const params = {
+      name
+    };
+    this.aggregator.store(type, name, params, metrics);
+  }
+  singleChecks() {
+    // report generic info about the agent itself
+    // note the browser agent version
+    this.storeSupportabilityMetrics(`Generic/Version/${VERSION}/Detected`);
+    // report loaderType
+    const {
+      distMethod,
+      loaderType
+    } = getRuntime(this.agentIdentifier);
+    if (loaderType) this.storeSupportabilityMetrics(`Generic/LoaderType/${loaderType}/Detected`);
+    if (distMethod) this.storeSupportabilityMetrics(`Generic/DistMethod/${distMethod}/Detected`);
+
+    // frameworks on page
+    if (isBrowserScope) {
+      onDOMContentLoaded(() => {
+        getFrameworks().forEach(framework => {
+          this.storeSupportabilityMetrics('Framework/' + framework + '/Detected');
+        });
+      });
+    }
+
+    // file protocol detection
+    if (protocol.isFileProtocol()) {
+      this.storeSupportabilityMetrics('Generic/FileProtocol/Detected');
+      protocol.supportabilityMetricSent = true;
+    }
+
+    // obfuscation rules detection
+    const rules = getRules(this.agentIdentifier);
+    if (rules.length > 0) this.storeSupportabilityMetrics('Generic/Obfuscate/Detected');
+    if (rules.length > 0 && !validateRules(rules)) this.storeSupportabilityMetrics('Generic/Obfuscate/Invalid');
+  }
+  eachSessionChecks() {
+    if (!isBrowserScope) return;
+
+    // [Temporary] Report restores from BFCache to NR1 while feature flag is in place in lieu of sending pageshow events.
+    windowAddEventListener('pageshow', evt => {
+      if (evt.persisted) {
+        this.storeSupportabilityMetrics('Generic/BFCache/PageRestored');
+      }
+      return;
+    });
+  }
+  unload() {
+    // Page Resources detection for estimations with resources feature work
+    // TODO - these SMs are to be removed when we implement the actual resources feature
+    try {
+      if (this.resourcesSent) return;
+      // make sure this only gets sent once
+      this.resourcesSent = true;
+      // differentiate between internal+external and ajax+non-ajax
+      const ajaxResources = ['beacon', 'fetch', 'xmlhttprequest'];
+      const internalUrls = ['nr-data.net', 'newrelic.com', 'nr-local.net', 'localhost'];
+      function isInternal(x) {
+        return internalUrls.some(y => x.name.indexOf(y) >= 0);
+      }
+      function isAjax(x) {
+        return ajaxResources.includes(x.initiatorType);
+      }
+      const allResources = performance?.getEntriesByType('resource') || [];
+      allResources.forEach(entry => {
+        if (isInternal(entry)) {
+          if (isAjax(entry)) this.storeSupportabilityMetrics('Generic/Resources/Ajax/Internal');else this.storeSupportabilityMetrics('Generic/Resources/Non-Ajax/Internal');
+        } else {
+          if (isAjax(entry)) this.storeSupportabilityMetrics('Generic/Resources/Ajax/External');else this.storeSupportabilityMetrics('Generic/Resources/Non-Ajax/External');
+        }
+      });
+    } catch (e) {
+      // do nothing
+    }
+  }
+}

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

@@ -0,0 +1,6 @@
+import { FEATURE_NAMES } from '../../loaders/features/features';
+export const FEATURE_NAME = FEATURE_NAMES.metrics;
+export const SUPPORTABILITY_METRIC = 'sm';
+export const CUSTOM_METRIC = 'cm';
+export const SUPPORTABILITY_METRIC_CHANNEL = 'storeSupportabilityMetrics';
+export const CUSTOM_METRIC_CHANNEL = 'storeEventMetrics';

package/dist/esm/features/metrics/index.js

@@ -0,0 +1 @@
+export { Instrument as Metrics } from './instrument/index';

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

@@ -0,0 +1,13 @@
+import { InstrumentBase } from '../../utils/instrument-base';
+import { insertSupportMetrics } from './workers-helper';
+import { FEATURE_NAME, SUPPORTABILITY_METRIC_CHANNEL } from '../constants';
+import { handle } from '../../../common/event-emitter/handle';
+import { FEATURE_NAMES } from '../../../loaders/features/features';
+export class Instrument extends InstrumentBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    insertSupportMetrics(tag => handle(SUPPORTABILITY_METRIC_CHANNEL, [tag], undefined, FEATURE_NAMES.metrics, this.ee));
+    this.importAggregator();
+  }
+}

package/dist/esm/features/metrics/instrument/workers-helper.js

@@ -0,0 +1,116 @@
+import { globalScope, isWorkerScope } from '../../../common/util/global-scope';
+import { warn } from '../../../common/util/console';
+
+/**
+ * True for each Worker type supported in browser's execution context. Not all browser versions may support certain Workers or options however.
+ * - Warning: service workers are not available on unsecured HTTP sites
+ */
+const workersApiIsSupported = {
+  dedicated: Boolean(globalScope?.Worker),
+  shared: Boolean(globalScope?.SharedWorker),
+  service: Boolean(globalScope?.navigator?.serviceWorker)
+};
+let origWorker, origSharedWorker, origServiceWorkerCreate;
+/**
+ * Un-instrument support metrics for Workers.
+ * @returns void
+ */
+function resetSupportability() {
+  if (origWorker) globalScope.Worker = origWorker; // Worker was changed by this module
+  if (origSharedWorker) globalScope.SharedWorker = origSharedWorker;
+  if (origServiceWorkerCreate) globalScope.navigator.serviceWorker.register = origServiceWorkerCreate;
+  origWorker = origSharedWorker = origServiceWorkerCreate = undefined;
+}
+
+/**
+ * Injects code to report Web Workers supportability and usage as metrics, replacing the native API in global scope as a side effect.
+ * @param {Function} report - a cb used to report data
+ * @returns void
+ */
+export function insertSupportMetrics(report) {
+  // Of the 3, the normal worker is the most widely supported, so we can be sure metric was already inserted w/o checking other 2.
+  if (origWorker) return;
+  if (!workersApiIsSupported.dedicated) {
+    reportUnavailable('All');
+    return; // similarly, if dedicated is n/a, none of them are supported so quit
+  } else {
+    origWorker = Worker;
+    try {
+      globalScope.Worker = extendWorkerConstructor(origWorker, 'Dedicated');
+    } catch (e) {
+      handleInsertionError(e, 'Dedicated');
+    }
+  }
+  if (!workersApiIsSupported.shared) {
+    reportUnavailable('Shared');
+  } else {
+    origSharedWorker = SharedWorker;
+    try {
+      globalScope.SharedWorker = extendWorkerConstructor(origSharedWorker, 'Shared');
+    } catch (e) {
+      handleInsertionError(e, 'Shared');
+    }
+  }
+  if (!workersApiIsSupported.service) {
+    reportUnavailable('Service');
+  } else {
+    origServiceWorkerCreate = navigator.serviceWorker.register;
+    try {
+      globalScope.navigator.serviceWorker.register = extendServiceCreation(origServiceWorkerCreate);
+    } catch (e) {
+      handleInsertionError(e, 'Service');
+    }
+  }
+  return;
+
+  // Internal helpers - Core
+  /**
+     * Report each time a Worker or SharedWorker is created in page execution. Note the current trap is set for only "new" and Reflect.construct operations.
+     * @param {func obj} origClass - Worker() or SharedWorker()
+     * @param {string} workerType - 'Dedicated' or 'Shared'
+     * @returns Proxy worker that intercepts the original constructor
+     */
+  function extendWorkerConstructor(origClass, workerType) {
+    if (typeof Proxy === 'undefined') {
+      return origClass;
+    }
+    const newHandler = {
+      construct(oConstructor, args) {
+        reportWorkerCreationAttempt(workerType, args[1]?.type);
+        return new oConstructor(...args);
+      }
+    };
+    // eslint-disable-next-line
+    return new Proxy(origClass, newHandler);
+  }
+  /**
+     * Report each time a ServiceWorkerRegistration is created or updated in page execution.
+     * @param {func} origFunc - method responsible for creating a ServiceWorker
+     * @returns Refer to ServiceWorkerContainer.register()
+     */
+  function extendServiceCreation(origFunc) {
+    return (...args) => {
+      reportWorkerCreationAttempt('Service', args[1]?.type);
+      return origFunc.apply(navigator.serviceWorker, args); // register() has to be rebound to the ServiceWorkerContainer object
+    };
+  }
+
+  // Internal helpers - Reporting & logging
+  function reportUnavailable(workerType) {
+    if (isWorkerScope) return; // assume that the main browser window has already reported unsupported worker APIs (once per page life);
+    // on top of that, not all workers are available inside a certain worker per se--e.g. no sharedWorker() inside Worker
+    report(`Workers/${workerType}/Unavailable`);
+  }
+  function reportWorkerCreationAttempt(workerType, optionType) {
+    if (optionType === 'module') {
+      report(`Workers/${workerType}/Module`);
+    } else {
+      report(`Workers/${workerType}/Classic`);
+    }
+  }
+  function handleInsertionError(e, workerType) {
+    // indicates the browser version doesn't support how code is injected, such as Proxy API
+    report(`Workers/${workerType}/SM/Unsupported`); // expected to be niche & for older borderline-ES6 browser versions
+    warn(`NR Agent: Unable to capture ${workerType} workers.`, e);
+  }
+}

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

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { mapOwn } from '../../../common/util/map-own';
+import { stringify } from '../../../common/util/stringify';
+import { registerHandler as register } from '../../../common/event-emitter/register-handler';
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
+import { cleanURL } from '../../../common/url/clean-url';
+import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
+import { AggregateBase } from '../../utils/aggregate-base';
+import { FEATURE_NAME } from '../constants';
+import { drain } from '../../../common/drain/drain';
+import { isBrowserScope } from '../../../common/util/global-scope';
+export class Aggregate extends AggregateBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, FEATURE_NAME);
+    this.eventsPerMinute = 240;
+    this.harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'page_action.harvestTimeSeconds') || getConfigurationValue(this.agentIdentifier, 'ins.harvestTimeSeconds') || 30;
+    this.eventsPerHarvest = this.eventsPerMinute * this.harvestTimeSeconds / 60;
+    this.referrerUrl;
+    this.currentEvents;
+    this.events = [];
+    this.att = getInfo(this.agentIdentifier).jsAttributes; // per-agent, aggregators-shared info context
+
+    if (isBrowserScope && document.referrer) this.referrerUrl = cleanURL(document.referrer);
+    register('api-addPageAction', (...args) => this.addPageAction(...args), this.featureName, this.ee);
+    var scheduler = new HarvestScheduler('ins', {
+      onFinished: (...args) => this.onHarvestFinished(...args)
+    }, this);
+    scheduler.harvest.on('ins', (...args) => this.onHarvestStarted(...args));
+    this.ee.on(`drain-${this.featureName}`, () => {
+      if (!this.blocked) scheduler.startTimer(this.harvestTimeSeconds, 0);
+    });
+
+    // if rum response determines that customer lacks entitlements for ins endpoint, block it
+    register('block-ins', () => {
+      this.blocked = true;
+      scheduler.stopTimer(true);
+    }, this.featureName, this.ee);
+    drain(this.agentIdentifier, this.featureName);
+  }
+  onHarvestStarted(options) {
+    const {
+      userAttributes,
+      atts
+    } = getInfo(this.agentIdentifier);
+    var payload = {
+      qs: {
+        ua: userAttributes,
+        at: atts
+      },
+      body: {
+        ins: this.events
+      }
+    };
+    if (options.retry) {
+      this.currentEvents = this.events;
+    }
+    this.events = [];
+    return payload;
+  }
+  onHarvestFinished(result) {
+    if (result && result.sent && result.retry && this.currentEvents) {
+      this.events = this.events.concat(this.currentEvents);
+      this.currentEvents = null;
+    }
+  }
+
+  // WARNING: Insights times are in seconds. EXCEPT timestamp, which is in ms.
+  addPageAction(t, name, attributes) {
+    if (this.events.length >= this.eventsPerHarvest || this.blocked) return;
+    var width;
+    var height;
+    var eventAttributes = {};
+    if (isBrowserScope && window.document.documentElement) {
+      // Doesn't include the nav bar when it disappears in mobile safari
+      // https://github.com/jquery/jquery/blob/10399ddcf8a239acc27bdec9231b996b178224d3/src/dimensions.js#L23
+      width = window.document.documentElement.clientWidth;
+      height = window.document.documentElement.clientHeight;
+    }
+    var defaults = {
+      timestamp: t + getRuntime(this.agentIdentifier).offset,
+      timeSinceLoad: t / 1000,
+      browserWidth: width,
+      browserHeight: height,
+      referrerUrl: this.referrerUrl,
+      currentUrl: cleanURL('' + location),
+      pageUrl: cleanURL(getRuntime(this.agentIdentifier).origin),
+      eventType: 'PageAction'
+    };
+    mapOwn(defaults, set);
+    mapOwn(getInfo(this.agentIdentifier).jsAttributes, set);
+    if (attributes && typeof attributes === 'object') {
+      mapOwn(attributes, set);
+    }
+    eventAttributes.actionName = name || '';
+    this.events.push(eventAttributes);
+    function set(key, val) {
+      eventAttributes[key] = val && typeof val === 'object' ? stringify(val) : val;
+    }
+  }
+}

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

@@ -0,0 +1,2 @@
+import { FEATURE_NAMES } from '../../loaders/features/features';
+export const FEATURE_NAME = FEATURE_NAMES.pageAction;

package/dist/esm/features/page_action/index.js

@@ -0,0 +1 @@
+export { Instrument as PageAction } from './instrument/index';

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

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { InstrumentBase } from '../../utils/instrument-base';
+import { FEATURE_NAME } from '../constants';
+export class Instrument extends InstrumentBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    this.importAggregator();
+  }
+}

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

@@ -0,0 +1,124 @@
+import { handle } from '../../../common/event-emitter/handle';
+import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { isiOS } from '../../../common/browser-version/ios-version';
+import { onTTFB } from 'web-vitals';
+import { mapOwn } from '../../../common/util/map-own';
+import { param, fromArray } from '../../../common/url/encode';
+import { addPT, addPN } from '../../../common/timing/nav-timing';
+import { stringify } from '../../../common/util/stringify';
+import { paintMetrics } from '../../../common/metrics/paint-metrics';
+import { submitData } from '../../../common/util/submit-data';
+import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
+import { AggregateBase } from '../../utils/aggregate-base';
+import * as CONSTANTS from '../constants';
+import { getActivatedFeaturesFlags } from './initialized-features';
+import { globalScope, isBrowserScope } from '../../../common/util/global-scope';
+import { drain } from '../../../common/drain/drain';
+const jsonp = 'NREUM.setToken';
+export class Aggregate extends AggregateBase {
+  static featureName = CONSTANTS.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME);
+    if (typeof PerformanceNavigationTiming !== 'undefined' && !isiOS) {
+      this.alreadySent = false; // we don't support timings on BFCache restores
+      const agentRuntime = getRuntime(agentIdentifier); // we'll store timing values on the runtime obj to be read by the aggregate module
+
+      /* Time To First Byte
+        This listener must record these values *before* PVE's aggregate sends RUM. */
+      onTTFB(({
+        value,
+        entries
+      }) => {
+        if (this.alreadySent) return;
+        this.alreadySent = true;
+        agentRuntime[CONSTANTS.TTFB] = Math.round(value); // this is our "backend" duration; web-vitals will ensure it's lower bounded at 0
+
+        // Similar to what vitals does for ttfb, we have to factor in activation-start when calculating relative timings:
+        const navEntry = entries[0];
+        const respOrActivStart = Math.max(navEntry.responseStart, navEntry.activationStart || 0);
+        agentRuntime[CONSTANTS.FBTWL] = Math.max(Math.round(navEntry.loadEventEnd - respOrActivStart), 0); // our "frontend" duration
+        handle('timing', ['load', Math.round(navEntry.loadEventEnd)], undefined, FEATURE_NAMES.pageViewTiming, this.ee);
+        agentRuntime[CONSTANTS.FBTDC] = Math.max(Math.round(navEntry.domContentLoadedEventEnd - respOrActivStart), 0); // our "dom processing" duration
+
+        this.sendRum();
+      });
+    } else {
+      this.sendRum(); // timings either already in runtime from instrument or is meant to get 0'd.
+    }
+  }
+
+  getScheme() {
+    return getConfigurationValue(this.agentIdentifier, 'ssl') === false ? 'http' : 'https';
+  }
+  sendRum() {
+    const info = getInfo(this.agentIdentifier);
+    if (!info.beacon) return;
+    if (info.queueTime) this.aggregator.store('measures', 'qt', {
+      value: info.queueTime
+    });
+    if (info.applicationTime) this.aggregator.store('measures', 'ap', {
+      value: info.applicationTime
+    });
+    const agentRuntime = getRuntime(this.agentIdentifier);
+
+    // These 3 values should've been recorded after load and before this func runs. They are part of the minimum required for PageView events to be created.
+    // Following PR #428, which demands that all agents send RUM call, these need to be sent even outside of the main window context where PerformanceTiming
+    // or PerformanceNavigationTiming do not exists. Hence, they'll be filled in by 0s instead in, for example, worker threads that still init the PVE module.
+    this.aggregator.store('measures', 'be', {
+      value: isBrowserScope ? agentRuntime[CONSTANTS.TTFB] : 0
+    });
+    this.aggregator.store('measures', 'fe', {
+      value: isBrowserScope ? agentRuntime[CONSTANTS.FBTWL] : 0
+    });
+    this.aggregator.store('measures', 'dc', {
+      value: isBrowserScope ? agentRuntime[CONSTANTS.FBTDC] : 0
+    });
+    var measuresMetrics = this.aggregator.get('measures');
+    var measuresQueryString = mapOwn(measuresMetrics, function (metricName, measure) {
+      return '&' + metricName + '=' + measure.params.value;
+    }).join('');
+
+    // currently we only have one version of our protocol
+    // in the future we may add more
+    var protocol = '1';
+    var scheduler = new HarvestScheduler('page_view_event', {}, this);
+    var chunksForQueryString = [scheduler.harvest.baseQueryString()];
+    chunksForQueryString.push(measuresQueryString);
+    chunksForQueryString.push(param('tt', info.ttGuid));
+    chunksForQueryString.push(param('us', info.user));
+    chunksForQueryString.push(param('ac', info.account));
+    chunksForQueryString.push(param('pr', info.product));
+    chunksForQueryString.push(param('af', getActivatedFeaturesFlags(this.agentIdentifier).join(',')));
+    if (globalScope.performance && typeof globalScope.performance.timing !== 'undefined') {
+      var navTimingApiData = {
+        timing: addPT(agentRuntime.offset, globalScope.performance.timing, {}),
+        navigation: addPN(globalScope.performance.navigation, {})
+      };
+      chunksForQueryString.push(param('perf', stringify(navTimingApiData)));
+    }
+    try {
+      // PVTiming sends these too, albeit using web-vitals and slightly different; it's unknown why they're duplicated, but PVT should be the truth
+      var entries = globalScope.performance.getEntriesByType('paint');
+      entries.forEach(function (entry) {
+        if (!entry.startTime || entry.startTime <= 0) return;
+        if (entry.name === 'first-paint') {
+          chunksForQueryString.push(param('fp', String(Math.floor(entry.startTime))));
+        } else if (entry.name === 'first-contentful-paint') {
+          chunksForQueryString.push(param('fcp', String(Math.floor(entry.startTime))));
+        }
+        paintMetrics[entry.name] = Math.floor(entry.startTime); // this is consumed by Spa module
+      });
+    } catch (e) {}
+    chunksForQueryString.push(param('xx', info.extra));
+    chunksForQueryString.push(param('ua', info.userAttributes));
+    chunksForQueryString.push(param('at', info.atts));
+    var customJsAttributes = stringify(info.jsAttributes);
+    chunksForQueryString.push(param('ja', customJsAttributes === '{}' ? null : customJsAttributes));
+    var queryString = fromArray(chunksForQueryString, agentRuntime.maxBytes);
+    const isValidJsonp = submitData.jsonp(this.getScheme() + '://' + info.beacon + '/' + protocol + '/' + info.licenseKey + queryString, jsonp);
+    // Usually `drain` is invoked automatically after processing feature flags contained in the JSONP callback from
+    // ingest (see `activateFeatures`), so when JSONP cannot execute (as with module workers), we drain manually.
+    if (!isValidJsonp) drain(this.agentIdentifier, CONSTANTS.FEATURE_NAME);
+  }
+}