@newrelic/browser-agent 0.0.9 → 0.1.229

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

@@ -0,0 +1,40 @@
+"use strict";
+
+var _contextualEe = require("../../../common/event-emitter/contextual-ee");
+var _mapOwn = require("../../../common/util/map-own");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+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) _contextualEe.ee.on('internal-error', function (err) {
+  log(err.stack);
+});
+if (flags.dev) _contextualEe.ee.on('fn-err', function (args, origThis, err) {
+  log(err.stack);
+});
+if (flags.dev) {
+  log('NR AGENT IN DEVELOPMENT MODE');
+  log('flags: ' + (0, _mapOwn.mapOwn)(flags, function (key, val) {
+    return key;
+  }).join(', '));
+}
+function log(message) {
+  try {
+    if (flags.console) log(message);
+  } catch (err) {
+    // no op
+  }
+}

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

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Instrument = void 0;
+var _handle = require("../../../common/event-emitter/handle");
+var _now = require("../../../common/timing/now");
+var _getOrSet = require("../../../common/util/get-or-set");
+var _wrap = require("../../../common/wrap");
+var _lodash = _interopRequireDefault(require("lodash._slice"));
+require("./debug");
+var _instrumentBase = require("../../utils/instrument-base");
+var _constants = require("../constants");
+var _features = require("../../../loaders/features/features");
+var _globalScope = require("../../../common/util/global-scope");
+var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
+var _config = require("../../../common/config/config");
+var _stringify = require("../../../common/util/stringify");
+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 Instrument extends _instrumentBase.InstrumentBase {
+  static featureName = _constants.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, _constants.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.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[_constants.NR_ERR_PROP]) {
+        (0, _getOrSet.getOrSet)(err, _constants.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) {
+      (0, _handle.handle)('ierr', [e, (0, _now.now)(), true], undefined, _features.FEATURE_NAMES.jserrors, thisInstrument.ee);
+    });
+
+    // Tack on our error handler onto the existing global one.
+    _globalScope.globalScope.onerror = (...args) => {
+      if (this.origOnerror) this.origOnerror(...args);
+      this.onerrorHandler(...args);
+      return false;
+    };
+    _globalScope.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);
+      (0, _handle.handle)('err', [err, (0, _now.now)(), false, {
+        unhandledPromiseRejection: 1
+      }], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+    }, (0, _eventListenerOpts.eventListenerOpts)(false, this.removeOnAbort?.signal));
+    (0, _wrap.wrapRaf)(this.ee);
+    (0, _wrap.wrapTimer)(this.ee);
+    (0, _wrap.wrapEvents)(this.ee);
+    if ((0, _config.getRuntime)(agentIdentifier).xhrWrappable) (0, _wrap.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 {
+        (0, _handle.handle)('ierr', [e, (0, _now.now)(), true], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+      } catch (err) {
+        // do nothing
+      }
+    }
+    if (typeof this.origOnerror === 'function') return this.origOnerror.apply(this, (0, _lodash.default)(arguments));
+    return false;
+  }
+}
+
+/**
+ *
+ * @param {string} message
+ * @param {string} filename
+ * @param {number} lineno
+ */
+exports.Instrument = Instrument;
+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 ? (0, _now.now)() : null;
+  (0, _handle.handle)('err', [err, time], undefined, _features.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 + (0, _stringify.stringify)(reason));
+  } catch (err) {
+    return new Error(prefix);
+  }
+}

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

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Aggregate = void 0;
+var _config = require("../../../common/config/config");
+var _registerHandler = require("../../../common/event-emitter/register-handler");
+var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
+var _aggregateBase = require("../../utils/aggregate-base");
+var _constants = require("../constants");
+var _drain = require("../../../common/drain/drain");
+var _frameworkDetection = require("../../../common/metrics/framework-detection");
+var _protocol = require("../../../common/url/protocol");
+var _obfuscate = require("../../../common/util/obfuscate");
+var _environmentVariables = require("../../../common/constants/environment-variables");
+var _load = require("../../../common/window/load");
+var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
+var _globalScope = require("../../../common/util/global-scope");
+class Aggregate extends _aggregateBase.AggregateBase {
+  static featureName = _constants.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
+    let scheduler;
+
+    // If RUM-call's response determines that customer lacks entitlements for the /jserror ingest endpoint, don't harvest at all.
+    (0, _registerHandler.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
+    (0, _registerHandler.registerHandler)(_constants.SUPPORTABILITY_METRIC_CHANNEL, this.storeSupportabilityMetrics.bind(this), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)(_constants.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.HarvestScheduler('jserrors', {
+      onUnload: () => this.unload()
+    }, this);
+    scheduler.harvest.on('jserrors', () => ({
+      body: this.aggregator.take(['cm', 'sm'])
+    }));
+    (0, _drain.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 = _constants.SUPPORTABILITY_METRIC;
+    const params = {
+      name
+    };
+    this.aggregator.storeMetric(type, name, params, value);
+  }
+  storeEventMetrics(name, metrics) {
+    if (this.blocked) return;
+    const type = _constants.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/${_environmentVariables.VERSION}/Detected`);
+    // report loaderType
+    const {
+      distMethod,
+      loaderType
+    } = (0, _config.getRuntime)(this.agentIdentifier);
+    if (loaderType) this.storeSupportabilityMetrics(`Generic/LoaderType/${loaderType}/Detected`);
+    if (distMethod) this.storeSupportabilityMetrics(`Generic/DistMethod/${distMethod}/Detected`);
+
+    // frameworks on page
+    if (_globalScope.isBrowserScope) {
+      (0, _load.onDOMContentLoaded)(() => {
+        (0, _frameworkDetection.getFrameworks)().forEach(framework => {
+          this.storeSupportabilityMetrics('Framework/' + framework + '/Detected');
+        });
+      });
+    }
+
+    // file protocol detection
+    if (_protocol.protocol.isFileProtocol()) {
+      this.storeSupportabilityMetrics('Generic/FileProtocol/Detected');
+      _protocol.protocol.supportabilityMetricSent = true;
+    }
+
+    // obfuscation rules detection
+    const rules = (0, _obfuscate.getRules)(this.agentIdentifier);
+    if (rules.length > 0) this.storeSupportabilityMetrics('Generic/Obfuscate/Detected');
+    if (rules.length > 0 && !(0, _obfuscate.validateRules)(rules)) this.storeSupportabilityMetrics('Generic/Obfuscate/Invalid');
+  }
+  eachSessionChecks() {
+    if (!_globalScope.isBrowserScope) return;
+
+    // [Temporary] Report restores from BFCache to NR1 while feature flag is in place in lieu of sending pageshow events.
+    (0, _eventListenerOpts.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
+    }
+  }
+}
+exports.Aggregate = Aggregate;

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SUPPORTABILITY_METRIC_CHANNEL = exports.SUPPORTABILITY_METRIC = exports.FEATURE_NAME = exports.CUSTOM_METRIC_CHANNEL = exports.CUSTOM_METRIC = void 0;
+var _features = require("../../loaders/features/features");
+const FEATURE_NAME = _features.FEATURE_NAMES.metrics;
+exports.FEATURE_NAME = FEATURE_NAME;
+const SUPPORTABILITY_METRIC = 'sm';
+exports.SUPPORTABILITY_METRIC = SUPPORTABILITY_METRIC;
+const CUSTOM_METRIC = 'cm';
+exports.CUSTOM_METRIC = CUSTOM_METRIC;
+const SUPPORTABILITY_METRIC_CHANNEL = 'storeSupportabilityMetrics';
+exports.SUPPORTABILITY_METRIC_CHANNEL = SUPPORTABILITY_METRIC_CHANNEL;
+const CUSTOM_METRIC_CHANNEL = 'storeEventMetrics';
+exports.CUSTOM_METRIC_CHANNEL = CUSTOM_METRIC_CHANNEL;

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Instrument = void 0;
+var _instrumentBase = require("../../utils/instrument-base");
+var _workersHelper = require("./workers-helper");
+var _constants = require("../constants");
+var _handle = require("../../../common/event-emitter/handle");
+var _features = require("../../../loaders/features/features");
+class Instrument extends _instrumentBase.InstrumentBase {
+  static featureName = _constants.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, _constants.FEATURE_NAME, auto);
+    (0, _workersHelper.insertSupportMetrics)(tag => (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, [tag], undefined, _features.FEATURE_NAMES.metrics, this.ee));
+    this.importAggregator();
+  }
+}
+exports.Instrument = Instrument;

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

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertSupportMetrics = insertSupportMetrics;
+var _globalScope = require("../../../common/util/global-scope");
+var _console = require("../../../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.globalScope?.Worker),
+  shared: Boolean(_globalScope.globalScope?.SharedWorker),
+  service: Boolean(_globalScope.globalScope?.navigator?.serviceWorker)
+};
+let origWorker, origSharedWorker, origServiceWorkerCreate;
+/**
+ * Un-instrument support metrics for Workers.
+ * @returns void
+ */
+function resetSupportability() {
+  if (origWorker) _globalScope.globalScope.Worker = origWorker; // Worker was changed by this module
+  if (origSharedWorker) _globalScope.globalScope.SharedWorker = origSharedWorker;
+  if (origServiceWorkerCreate) _globalScope.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
+ */
+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.globalScope.Worker = extendWorkerConstructor(origWorker, 'Dedicated');
+    } catch (e) {
+      handleInsertionError(e, 'Dedicated');
+    }
+  }
+  if (!workersApiIsSupported.shared) {
+    reportUnavailable('Shared');
+  } else {
+    origSharedWorker = SharedWorker;
+    try {
+      _globalScope.globalScope.SharedWorker = extendWorkerConstructor(origSharedWorker, 'Shared');
+    } catch (e) {
+      handleInsertionError(e, 'Shared');
+    }
+  }
+  if (!workersApiIsSupported.service) {
+    reportUnavailable('Service');
+  } else {
+    origServiceWorkerCreate = navigator.serviceWorker.register;
+    try {
+      _globalScope.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 (_globalScope.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
+    (0, _console.warn)(`NR Agent: Unable to capture ${workerType} workers.`, e);
+  }
+}

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

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Aggregate = void 0;
+var _mapOwn = require("../../../common/util/map-own");
+var _stringify = require("../../../common/util/stringify");
+var _registerHandler = require("../../../common/event-emitter/register-handler");
+var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
+var _cleanUrl = require("../../../common/url/clean-url");
+var _config = require("../../../common/config/config");
+var _aggregateBase = require("../../utils/aggregate-base");
+var _constants = require("../constants");
+var _drain = require("../../../common/drain/drain");
+var _globalScope = require("../../../common/util/global-scope");
+/*
+ * 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);
+    this.eventsPerMinute = 240;
+    this.harvestTimeSeconds = (0, _config.getConfigurationValue)(this.agentIdentifier, 'page_action.harvestTimeSeconds') || (0, _config.getConfigurationValue)(this.agentIdentifier, 'ins.harvestTimeSeconds') || 30;
+    this.eventsPerHarvest = this.eventsPerMinute * this.harvestTimeSeconds / 60;
+    this.referrerUrl;
+    this.currentEvents;
+    this.events = [];
+    this.att = (0, _config.getInfo)(this.agentIdentifier).jsAttributes; // per-agent, aggregators-shared info context
+
+    if (_globalScope.isBrowserScope && document.referrer) this.referrerUrl = (0, _cleanUrl.cleanURL)(document.referrer);
+    (0, _registerHandler.registerHandler)('api-addPageAction', (...args) => this.addPageAction(...args), this.featureName, this.ee);
+    var scheduler = new _harvestScheduler.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
+    (0, _registerHandler.registerHandler)('block-ins', () => {
+      this.blocked = true;
+      scheduler.stopTimer(true);
+    }, this.featureName, this.ee);
+    (0, _drain.drain)(this.agentIdentifier, this.featureName);
+  }
+  onHarvestStarted(options) {
+    const {
+      userAttributes,
+      atts
+    } = (0, _config.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 (_globalScope.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 + (0, _config.getRuntime)(this.agentIdentifier).offset,
+      timeSinceLoad: t / 1000,
+      browserWidth: width,
+      browserHeight: height,
+      referrerUrl: this.referrerUrl,
+      currentUrl: (0, _cleanUrl.cleanURL)('' + location),
+      pageUrl: (0, _cleanUrl.cleanURL)((0, _config.getRuntime)(this.agentIdentifier).origin),
+      eventType: 'PageAction'
+    };
+    (0, _mapOwn.mapOwn)(defaults, set);
+    (0, _mapOwn.mapOwn)((0, _config.getInfo)(this.agentIdentifier).jsAttributes, set);
+    if (attributes && typeof attributes === 'object') {
+      (0, _mapOwn.mapOwn)(attributes, set);
+    }
+    eventAttributes.actionName = name || '';
+    this.events.push(eventAttributes);
+    function set(key, val) {
+      eventAttributes[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
+    }
+  }
+}
+exports.Aggregate = Aggregate;

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

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FEATURE_NAME = void 0;
+var _features = require("../../loaders/features/features");
+const FEATURE_NAME = _features.FEATURE_NAMES.pageAction;
+exports.FEATURE_NAME = FEATURE_NAME;

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

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

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Instrument = void 0;
+var _instrumentBase = require("../../utils/instrument-base");
+var _constants = require("../constants");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+class Instrument extends _instrumentBase.InstrumentBase {
+  static featureName = _constants.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, _constants.FEATURE_NAME, auto);
+    this.importAggregator();
+  }
+}
+exports.Instrument = Instrument;