@newrelic/browser-agent 0.0.9 → 0.1.230

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ee } from '../../../common/event-emitter/contextual-ee';
+import { mapOwn } from '../../../common/util/map-own';
+var flags = {};
+var flagArr;
+try {
+  flagArr = localStorage.getItem('__nr_flags').split(',');
+  if (console && typeof console.log === 'function') {
+    flags.console = true;
+    if (flagArr.indexOf('dev') !== -1) flags.dev = true;
+    if (flagArr.indexOf('nr_dev') !== -1) flags.nrDev = true;
+  }
+} catch (err) {
+  // no op
+}
+if (flags.nrDev) ee.on('internal-error', function (err) {
+  log(err.stack);
+});
+if (flags.dev) ee.on('fn-err', function (args, origThis, err) {
+  log(err.stack);
+});
+if (flags.dev) {
+  log('NR AGENT IN DEVELOPMENT MODE');
+  log('flags: ' + mapOwn(flags, function (key, val) {
+    return key;
+  }).join(', '));
+}
+function log(message) {
+  try {
+    if (flags.console) log(message);
+  } catch (err) {
+    // no op
+  }
+}

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

@@ -0,0 +1,147 @@
+/*
+ * 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) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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;
+    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);
+    });
+
+    // Replace global error handler with our own.
+    this.origOnerror = globalScope.onerror;
+    globalScope.onerror = this.onerrorHandler.bind(this);
+    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) {
+    if (typeof this.origOnerror === 'function') this.origOnerror(...arguments);
+    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
+      }
+    }
+    return false; // maintain default behavior of the error event of Window
+  }
+}
+
+/**
+ *
+ * @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,140 @@
+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;
+      const agentRuntime = getRuntime(this.agentIdentifier);
+      // 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');
+        }
+      });
+
+      // Capture per-agent bytes sent for each endpoint (see harvest) and RUM call (see page_view_event aggregator).
+      Object.keys(agentRuntime.bytesSent).forEach(endpoint => {
+        this.storeSupportabilityMetrics(`PageSession/Endpoint/${endpoint.charAt(0).toUpperCase() + endpoint.slice(1)}/BytesSent`, agentRuntime.bytesSent[endpoint]);
+      });
+
+      // Capture metrics for session trace if active (`ptid` is set when returned by replay ingest).
+      if (agentRuntime.ptid) {
+        this.storeSupportabilityMetrics('PageSession/Feature/SessionTrace/DurationMs', Math.round(performance.now()));
+      }
+    } 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,39 @@
+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';
+import { wrapConsole } from '../../../common/wrap';
+import { stringify } from '../../../common/util/stringify';
+export class Instrument extends InstrumentBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    insertSupportMetrics(tag => handle(SUPPORTABILITY_METRIC_CHANNEL, [tag], undefined, FEATURE_NAMES.metrics, this.ee));
+    this.addConsoleSupportabilityMetrics();
+    this.importAggregator();
+  }
+  addConsoleSupportabilityMetrics() {
+    // For now we are just capturing supportability metrics on `console` usage to assess log forwarding feature.
+    const consoleEE = wrapConsole(this.ee);
+    for (const method of ['Debug', 'Error', 'Info', 'Log', 'Trace', 'Warn']) {
+      consoleEE.on(`${method.toLowerCase()}-console-start`, function (args, target) {
+        // Parsing the args individually into a new array ensures that functions and Error objects are represented with
+        // useful string values. By default, functions stringify to null and Error objects stringify to empty objects.
+        // Note that stack traces printed by the console.trace method are not captured.
+        let parsedArgs = [];
+        for (const arg of args) {
+          if (typeof arg === 'function' || arg && arg.message && arg.stack // Duck typing for Error objects
+          ) {
+            parsedArgs.push(arg.toString());
+          } else {
+            parsedArgs.push(arg);
+          }
+        }
+        const parsedArgsJSON = stringify(parsedArgs);
+        handle(SUPPORTABILITY_METRIC_CHANNEL, [`Console/${method}/Seen`, parsedArgsJSON.length], undefined, FEATURE_NAMES.metrics, consoleEE);
+      });
+    }
+  }
+}

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

@@ -0,0 +1,119 @@
+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 function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      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,113 @@
+/*
+ * 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) {
+    var _this;
+    super(agentIdentifier, aggregator, FEATURE_NAME);
+    _this = this;
+    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', function () {
+      return _this.addPageAction(...arguments);
+    }, this.featureName, this.ee);
+    var scheduler = new HarvestScheduler('ins', {
+      onFinished: function () {
+        return _this.onHarvestFinished(...arguments);
+      }
+    }, this);
+    scheduler.harvest.on('ins', function () {
+      return _this.onHarvestStarted(...arguments);
+    });
+    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,15 @@
+/*
+ * 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) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto);
+    this.importAggregator();
+  }
+}