@newrelic/browser-agent 0.0.9 → 0.1.230

package/dist/esm/features/utils/lazy-loader.js

@@ -0,0 +1,37 @@
+import { FEATURE_NAMES } from '../../loaders/features/features';
+
+/**
+ * Centralizes the lazy loading of agent feature aggregate and instrument sources.
+ *
+ * This function uses two defined switch cases to allow us to easily name our chunks and re-use these
+ * chunks for different agent types. We do not use template strings or string concatenation here because
+ * doing so makes it much more difficult to name the chunks and forces Webpack to "guess" what the chunks
+ * should be.
+ * @param featureName Name of the feature to import such as ajax or session_trace
+ * @param featurePart Name of the feature part to load; should be either instrument or aggregate
+ * @returns {Promise<InstrumentBase|AggregateBase|null>}
+ */
+export function lazyLoader(featureName, featurePart) {
+  if (featurePart === 'aggregate') {
+    switch (featureName) {
+      case FEATURE_NAMES.ajax:
+        return import( /* webpackChunkName: "ajax-aggregate" */'../ajax/aggregate');
+      case FEATURE_NAMES.jserrors:
+        return import( /* webpackChunkName: "jserrors-aggregate" */'../jserrors/aggregate');
+      case FEATURE_NAMES.metrics:
+        return import( /* webpackChunkName: "metrics-aggregate" */'../metrics/aggregate');
+      case FEATURE_NAMES.pageAction:
+        return import( /* webpackChunkName: "page_action-aggregate" */'../page_action/aggregate');
+      case FEATURE_NAMES.pageViewEvent:
+        return import( /* webpackChunkName: "page_view_event-aggregate" */'../page_view_event/aggregate');
+      case FEATURE_NAMES.pageViewTiming:
+        return import( /* webpackChunkName: "page_view_timing-aggregate" */'../page_view_timing/aggregate');
+      case FEATURE_NAMES.sessionTrace:
+        return import( /* webpackChunkName: "session_trace-aggregate" */'../session_trace/aggregate');
+      case FEATURE_NAMES.spa:
+        return import( /* webpackChunkName: "spa-aggregate" */'../spa/aggregate');
+      default:
+        throw new Error(`Attempted to load unsupported agent feature: ${featureName} ${featurePart}`);
+    }
+  }
+}

package/dist/esm/index.js

@@ -0,0 +1,15 @@
+export { Agent } from './loaders/agent';
+export { BrowserAgent } from './loaders/browser-agent';
+export { WorkerAgent } from './loaders/worker-agent';
+
+/** IN-PROGRESS -- DOES NOT CURRENTLY WORK CORRECTLY */
+// export { MicroAgent } from './loaders/micro-agent'
+
+export { Ajax } from './features/ajax';
+export { JSErrors } from './features/jserrors';
+export { Metrics } from './features/metrics';
+export { PageAction } from './features/page_action';
+export { PageViewEvent } from './features/page_view_event';
+export { PageViewTiming } from './features/page_view_timing';
+export { SessionTrace } from './features/session_trace';
+export { Spa } from './features/spa';

package/dist/esm/loaders/agent.js

@@ -0,0 +1,78 @@
+// loader files
+import { getEnabledFeatures } from './features/enabled-features';
+import { configure } from './configure/configure';
+import { getFeatureDependencyNames } from './features/featureDependencies';
+import { featurePriority, FEATURE_NAMES } from './features/features';
+// required features
+import { Instrument as PageViewEvent } from '../features/page_view_event/instrument';
+// common files
+import { Aggregator } from '../common/aggregate/aggregator';
+import { gosNREUM, gosNREUMInitializedAgents } from '../common/window/nreum';
+import { generateRandomHexString } from '../common/ids/unique-id';
+import { getConfiguration, getInfo, getLoaderConfig, getRuntime } from '../common/config/config';
+import { warn } from '../common/util/console';
+import { stringify } from '../common/util/stringify';
+
+/**
+ * A flexible class that may be used to compose an agent from a select subset of feature modules. In applications
+ * sensitive to network load, this may result in smaller builds with slightly lower performance impact.
+ */
+export class Agent {
+  constructor(options) {
+    let agentIdentifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : generateRandomHexString(16);
+    this.agentIdentifier = agentIdentifier;
+    this.sharedAggregator = new Aggregator({
+      agentIdentifier: this.agentIdentifier
+    });
+    this.features = {};
+    this.desiredFeatures = new Set(options.features || []); // expected to be a list of static Instrument/InstrumentBase classes, see "spa.js" for example
+
+    // For Now... ALL agents must make the rum call whether the page_view_event feature was enabled or not.
+    // NR1 creates an index on the rum call, and if not seen for a few days, will remove the browser app!
+    // Future work is being planned to evaluate removing this behavior from the backend, but for now we must ensure this call is made
+    this.desiredFeatures.add(PageViewEvent);
+    Object.assign(this, configure(this.agentIdentifier, options, options.loaderType || 'agent'));
+    this.start();
+  }
+  get config() {
+    return {
+      info: getInfo(this.agentIdentifier),
+      init: getConfiguration(this.agentIdentifier),
+      loader_config: getLoaderConfig(this.agentIdentifier),
+      runtime: getRuntime(this.agentIdentifier)
+    };
+  }
+  start() {
+    const NR_FEATURES_REF_NAME = 'features';
+    // Attempt to initialize all the requested features (sequentially in prio order & synchronously), with any failure aborting the whole process.
+    try {
+      const enabledFeatures = getEnabledFeatures(this.agentIdentifier);
+      const featuresToStart = Array.from(this.desiredFeatures);
+      featuresToStart.sort((a, b) => featurePriority[a.featureName] - featurePriority[b.featureName]);
+      featuresToStart.forEach(f => {
+        // pageViewEvent must be enabled because RUM calls are not optional. See comment in constructor and PR 428.
+        if (enabledFeatures[f.featureName] || f.featureName === FEATURE_NAMES.pageViewEvent) {
+          const dependencies = getFeatureDependencyNames(f.featureName);
+          const hasAllDeps = dependencies.every(x => enabledFeatures[x]);
+          if (!hasAllDeps) warn(`${f.featureName} is enabled but one or more dependent features has been disabled (${stringify(dependencies)}). This may cause unintended consequences or missing data...`);
+          this.features[f.featureName] = new f(this.agentIdentifier, this.sharedAggregator);
+        }
+      });
+      gosNREUMInitializedAgents(this.agentIdentifier, this.features, NR_FEATURES_REF_NAME);
+    } catch (err) {
+      warn('Failed to initialize all enabled instrument classes (agent aborted) -', err);
+      for (const featName in this.features) {
+        // this.features hold only features that have been instantiated
+        this.features[featName].abortHandler?.();
+      }
+      const newrelic = gosNREUM();
+      delete newrelic.initializedAgents[this.agentIdentifier]?.['api']; // prevent further calls to agent-specific APIs (see "configure.js")
+      delete newrelic.initializedAgents[this.agentIdentifier]?.[NR_FEATURES_REF_NAME]; // GC mem used internally by features
+      delete this.sharedAggregator;
+      // Keep the initialized agent object with its configs for troubleshooting purposes.
+      newrelic.ee?.abort(); // set flag and clear global backlog
+      delete newrelic.ee?.get(this.agentIdentifier); // clear this agent's own backlog too
+      return false;
+    }
+  }
+}

package/dist/esm/loaders/api/api.js

@@ -0,0 +1,168 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FEATURE_NAMES } from '../features/features';
+import { getRuntime, setInfo, getInfo } from '../../common/config/config';
+import { handle } from '../../common/event-emitter/handle';
+import { ee } from '../../common/event-emitter/contextual-ee';
+import { now } from '../../common/timing/now';
+import { drain, registerDrain } from '../../common/drain/drain';
+import { onWindowLoad } from '../../common/window/load';
+import { isBrowserScope, isWorkerScope } from '../../common/util/global-scope';
+import { warn } from '../../common/util/console';
+import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants';
+import { gosCDN } from '../../common/window/nreum';
+import { putInBrowserStorage, removeFromBrowserStorage } from '../../common/window/session-storage';
+export const CUSTOM_ATTR_GROUP = 'CUSTOM/'; // the subgroup items should be stored under in storage API
+
+export function setTopLevelCallers() {
+  const nr = gosCDN();
+  const funcs = ['setErrorHandler', 'finished', 'addToTrace', 'inlineHit', 'addRelease', 'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute', 'interaction', 'noticeError', 'setUserId'];
+  funcs.forEach(f => {
+    nr[f] = function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return caller(f, ...args);
+    };
+  });
+  function caller(fnName) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+    let returnVals = [];
+    Object.values(nr.initializedAgents).forEach(val => {
+      if (val.exposed && val.api[fnName]) {
+        returnVals.push(val.api[fnName](...args));
+      }
+    });
+    return returnVals.length > 1 ? returnsVals : returnVals[0];
+  }
+}
+export function setAPI(agentIdentifier, forceDrain) {
+  if (!forceDrain) registerDrain(agentIdentifier, 'api');
+  const apiInterface = {};
+  var instanceEE = ee.get(agentIdentifier);
+  var tracerEE = instanceEE.get('tracer');
+  var asyncApiFns = ['setErrorHandler', 'finished', 'addToTrace', 'inlineHit', 'addRelease'];
+  var prefix = 'api-';
+  var spaPrefix = prefix + 'ixn-';
+
+  // Setup stub functions that queue calls for later processing.
+  asyncApiFns.forEach(fnName => apiInterface[fnName] = apiCall(prefix, fnName, true, 'api'));
+  apiInterface.addPageAction = apiCall(prefix, 'addPageAction', true, FEATURE_NAMES.pageAction);
+  apiInterface.setCurrentRouteName = apiCall(prefix, 'routeName', true, FEATURE_NAMES.spa);
+  apiInterface.setPageViewName = function (name, host) {
+    if (typeof name !== 'string') return;
+    if (name.charAt(0) !== '/') name = '/' + name;
+    getRuntime(agentIdentifier).customTransaction = (host || 'http://custom.transaction') + name;
+    return apiCall(prefix, 'setPageViewName', true)();
+  };
+
+  /**
+   * Attach the key-value attribute onto agent payloads. All browser events in NR will be affected.
+   * @param {string} key
+   * @param {string|number|null} value - null indicates the key should be removed or erased
+   * @param {string} apiName
+   * @param {boolean} addToBrowserStorage - whether this attribute should be stored in browser storage API and retrieved by the next agent context or initialization
+   * @returns @see apiCall
+   */
+  function appendJsAttribute(key, value, apiName, addToBrowserStorage) {
+    const currentInfo = getInfo(agentIdentifier);
+    if (value === null) {
+      delete currentInfo.jsAttributes[key];
+      if (isBrowserScope) removeFromBrowserStorage(key, CUSTOM_ATTR_GROUP); // addToBrowserStorage flag isn't needed to unset keys from storage
+    } else {
+      setInfo(agentIdentifier, {
+        ...currentInfo,
+        jsAttributes: {
+          ...currentInfo.jsAttributes,
+          [key]: value
+        }
+      });
+      if (isBrowserScope && addToBrowserStorage) putInBrowserStorage(key, value, CUSTOM_ATTR_GROUP);
+    }
+    return apiCall(prefix, apiName, true)();
+  }
+  apiInterface.setCustomAttribute = function (name, value) {
+    let persistAttribute = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    if (typeof name !== 'string') {
+      warn(`Failed to execute setCustomAttribute.\nName must be a string type, but a type of <${typeof name}> was provided.`);
+      return;
+    }
+    if (!(['string', 'number'].includes(typeof value) || value === null)) {
+      warn(`Failed to execute setCustomAttribute.\nNon-null value must be a string or number type, but a type of <${typeof value}> was provided.`);
+      return;
+    }
+    return appendJsAttribute(name, value, 'setCustomAttribute', persistAttribute);
+  };
+  /**
+   * Attach the 'enduser.id' attribute onto agent payloads. This may be used in NR queries to group all browser events by specific users.
+   * @param {string} value - unique user identifier; a null user id suggests none should exist
+   * @returns @see apiCall
+   */
+  apiInterface.setUserId = function (value) {
+    if (!(typeof value === 'string' || value === null)) {
+      warn(`Failed to execute setUserId.\nNon-null value must be a string type, but a type of <${typeof value}> was provided.`);
+      return;
+    }
+    return appendJsAttribute('enduser.id', value, 'setUserId', true);
+  };
+  apiInterface.interaction = function () {
+    return new InteractionHandle().get();
+  };
+  function InteractionHandle() {}
+  var InteractionApiProto = InteractionHandle.prototype = {
+    createTracer: function (name, cb) {
+      var contextStore = {};
+      var ixn = this;
+      var hasCb = typeof cb === 'function';
+      handle(spaPrefix + 'tracer', [now(), name, contextStore], ixn, FEATURE_NAMES.spa, instanceEE);
+      return function () {
+        tracerEE.emit((hasCb ? '' : 'no-') + 'fn-start', [now(), ixn, hasCb], contextStore);
+        if (hasCb) {
+          try {
+            return cb.apply(this, arguments);
+          } catch (err) {
+            tracerEE.emit('fn-err', [arguments, this, typeof err == 'string' ? new Error(err) : err], contextStore);
+            // the error came from outside the agent, so don't swallow
+            throw err;
+          } finally {
+            tracerEE.emit('fn-end', [now()], contextStore);
+          }
+        }
+      };
+    }
+  };
+  void ['actionText', 'setName', 'setAttribute', 'save', 'ignore', 'onEnd', 'getContext', 'end', 'get'].forEach(name => {
+    InteractionApiProto[name] = apiCall(spaPrefix, name, undefined, FEATURE_NAMES.spa);
+  });
+  function apiCall(prefix, name, notSpa, bufferGroup) {
+    return function () {
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/' + name + '/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
+      if (bufferGroup) handle(prefix + name, [now(), ...arguments], notSpa ? null : this, bufferGroup, instanceEE); // no bufferGroup means only the SM is emitted
+      return notSpa ? void 0 : this;
+    };
+  }
+  apiInterface.noticeError = function (err, customAttributes) {
+    if (typeof err === 'string') err = new Error(err);
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/noticeError/called'], undefined, FEATURE_NAMES.metrics, instanceEE);
+    handle('err', [err, now(), false, customAttributes], undefined, FEATURE_NAMES.jserrors, instanceEE);
+  };
+
+  // theres no window.load event on non-browser scopes, lazy load immediately
+  if (isWorkerScope) lazyLoad();
+  // try to stay out of the way of the window.load event, lazy load once that has finished.
+  else onWindowLoad(() => lazyLoad(), true);
+  function lazyLoad() {
+    import( /* webpackChunkName: "async-api" */'./apiAsync').then(_ref => {
+      let {
+        setAPI
+      } = _ref;
+      setAPI(agentIdentifier);
+      drain(agentIdentifier, 'api');
+    }).catch(() => warn('Downloading runtime APIs failed...'));
+  }
+  return apiInterface;
+}

package/dist/esm/loaders/api/apiAsync.js

@@ -0,0 +1,88 @@
+import { FEATURE_NAMES } from '../features/features';
+import { getConfigurationValue, getInfo, getRuntime } from '../../common/config/config';
+import { ee } from '../../common/event-emitter/contextual-ee';
+import { handle } from '../../common/event-emitter/handle';
+import { registerHandler } from '../../common/event-emitter/register-handler';
+import { single } from '../../common/util/single';
+import { submitData } from '../../common/util/submit-data';
+import { isBrowserScope } from '../../common/util/global-scope';
+import { CUSTOM_METRIC_CHANNEL } from '../../features/metrics/constants';
+export function setAPI(agentIdentifier) {
+  var instanceEE = ee.get(agentIdentifier);
+  var cycle = 0;
+  var scheme = getConfigurationValue(agentIdentifier, 'ssl') === false ? 'http' : 'https';
+  var api = {
+    finished: single(finished),
+    setErrorHandler: setErrorHandler,
+    addToTrace: addToTrace,
+    inlineHit: inlineHit,
+    addRelease: addRelease
+  };
+
+  // Hook all of the api functions up to the queues/stubs created in loader/api.js
+  Object.entries(api).forEach(_ref => {
+    let [fnName, fnCall] = _ref;
+    return registerHandler('api-' + fnName, fnCall, 'api', instanceEE);
+  });
+
+  // All API functions get passed the time they were called as their
+  // first parameter. These functions can be called asynchronously.
+
+  function finished(t, providedTime) {
+    var time = providedTime ? providedTime - getRuntime(agentIdentifier).offset : t;
+    handle(CUSTOM_METRIC_CHANNEL, ['finished', {
+      time
+    }], undefined, FEATURE_NAMES.metrics, instanceEE);
+    addToTrace(t, {
+      name: 'finished',
+      start: time + getRuntime(agentIdentifier).offset,
+      origin: 'nr'
+    });
+    handle('api-addPageAction', [time, 'finished'], undefined, FEATURE_NAMES.pageAction, instanceEE);
+  }
+  function addToTrace(t, evt) {
+    if (!(evt && typeof evt === 'object' && evt.name && evt.start)) return;
+    var report = {
+      n: evt.name,
+      s: evt.start - getRuntime(agentIdentifier).offset,
+      e: (evt.end || evt.start) - getRuntime(agentIdentifier).offset,
+      o: evt.origin || '',
+      t: 'api'
+    };
+    handle('bstApi', [report], undefined, FEATURE_NAMES.sessionTrace, instanceEE);
+  }
+
+  // NREUM.inlineHit(request_name, queue_time, app_time, total_be_time, dom_time, fe_time)
+  //
+  // request_name - the 'web page' name or service name
+  // queue_time - the amount of time spent in the app tier queue
+  // app_time - the amount of time spent in the application code
+  // total_be_time - the total roundtrip time of the remote service call
+  // dom_time - the time spent processing the result of the service call (or user defined)
+  // fe_time - the time spent rendering the result of the service call (or user defined)
+  function inlineHit(t, request_name, queue_time, app_time, total_be_time, dom_time, fe_time) {
+    if (!isBrowserScope) return;
+    request_name = window.encodeURIComponent(request_name);
+    cycle += 1;
+    const agentInfo = getInfo(agentIdentifier);
+    if (!agentInfo.beacon) return;
+    var url = scheme + '://' + agentInfo.beacon + '/1/' + agentInfo.licenseKey;
+    url += '?a=' + agentInfo.applicationID + '&';
+    url += 't=' + request_name + '&';
+    url += 'qt=' + ~~queue_time + '&';
+    url += 'ap=' + ~~app_time + '&';
+    url += 'be=' + ~~total_be_time + '&';
+    url += 'dc=' + ~~dom_time + '&';
+    url += 'fe=' + ~~fe_time + '&';
+    url += 'c=' + cycle;
+    submitData.img(url);
+  }
+  function setErrorHandler(t, handler) {
+    getRuntime(agentIdentifier).onerror = handler;
+  }
+  var releaseCount = 0;
+  function addRelease(t, name, id) {
+    if (++releaseCount > 10) return;
+    getRuntime(agentIdentifier).releaseIds[name.slice(-200)] = ('' + id).slice(-200);
+  }
+}

package/dist/esm/loaders/browser-agent.js

@@ -0,0 +1,23 @@
+import { Agent } from './agent';
+import { Instrument as InstrumentPageViewEvent } from '../features/page_view_event/instrument';
+import { Instrument as InstrumentPageViewTiming } from '../features/page_view_timing/instrument';
+import { Instrument as InstrumentMetrics } from '../features/metrics/instrument';
+import { Instrument as InstrumentErrors } from '../features/jserrors/instrument';
+import { Instrument as InstrumentXhr } from '../features/ajax/instrument';
+import { Instrument as InstrumentSessionTrace } from '../features/session_trace/instrument';
+import { Instrument as InstrumentSpa } from '../features/spa/instrument';
+import { Instrument as InstrumentPageAction } from '../features/page_action/instrument';
+
+/**
+ * An agent class with all feature modules available. Features may be disabled and enabled via runtime configuration.
+ * The BrowserAgent class is the most convenient and reliable option for most use cases.
+ */
+export class BrowserAgent extends Agent {
+  constructor(args) {
+    super({
+      ...args,
+      features: [InstrumentXhr, InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentMetrics, InstrumentPageAction, InstrumentErrors, InstrumentSpa],
+      loaderType: 'browser-agent'
+    });
+  }
+}

package/dist/esm/loaders/configure/configure.js

@@ -0,0 +1,47 @@
+import { setAPI, setTopLevelCallers, CUSTOM_ATTR_GROUP } from '../api/api';
+import { addToNREUM, gosCDN, gosNREUMInitializedAgents } from '../../common/window/nreum';
+import { setConfiguration, setInfo, setLoaderConfig, setRuntime } from '../../common/config/config';
+import { activateFeatures, activatedFeatures } from '../../common/util/feature-flags';
+import { isBrowserScope, isWorkerScope } from '../../common/util/global-scope';
+import { getAllStorageItemsOfGroup } from '../../common/window/session-storage';
+export function configure(agentIdentifier) {
+  let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let loaderType = arguments.length > 2 ? arguments[2] : undefined;
+  let forceDrain = arguments.length > 3 ? arguments[3] : undefined;
+  let {
+    init,
+    info,
+    loader_config,
+    runtime = {
+      loaderType
+    },
+    exposed = true
+  } = opts;
+  const nr = gosCDN();
+  if (!info) {
+    init = nr.init;
+    info = nr.info;
+    loader_config = nr.loader_config;
+  }
+  info.jsAttributes ??= {};
+  if (isWorkerScope) {
+    // add a default attr to all worker payloads
+    info.jsAttributes.isWorker = true;
+  }
+  if (isBrowserScope) {
+    // retrieve & re-add all of the persisted setCustomAttribute|setUserId k-v from previous page load(s)
+    let prevPageSessionJsAttrs = getAllStorageItemsOfGroup(CUSTOM_ATTR_GROUP);
+    Object.assign(info.jsAttributes, prevPageSessionJsAttrs);
+  }
+  setInfo(agentIdentifier, info);
+  setConfiguration(agentIdentifier, init || {});
+  setLoaderConfig(agentIdentifier, loader_config || {});
+  setRuntime(agentIdentifier, runtime);
+  setTopLevelCallers();
+  const api = setAPI(agentIdentifier, forceDrain);
+  gosNREUMInitializedAgents(agentIdentifier, api, 'api');
+  gosNREUMInitializedAgents(agentIdentifier, exposed, 'exposed');
+  addToNREUM('activatedFeatures', activatedFeatures);
+  addToNREUM('setToken', flags => activateFeatures(flags, agentIdentifier));
+  return api;
+}

package/dist/esm/loaders/features/enabled-features.js

@@ -0,0 +1,13 @@
+import { FEATURE_NAMES } from './features';
+import { getConfigurationValue, getRuntime } from '../../common/config/config';
+const featureNames = Object.values(FEATURE_NAMES);
+function isEnabled(name, agentIdentifier) {
+  return getConfigurationValue(agentIdentifier, `${name}.enabled`) !== false;
+}
+export function getEnabledFeatures(agentIdentifier) {
+  const enabledFeatures = {};
+  featureNames.forEach(featureName => {
+    enabledFeatures[featureName] = isEnabled(featureName, agentIdentifier);
+  });
+  return enabledFeatures;
+}

package/dist/esm/loaders/features/featureDependencies.js

@@ -0,0 +1,25 @@
+import { FEATURE_NAMES } from './features';
+export function getFeatureDependencyNames(feature) {
+  switch (feature) {
+    case FEATURE_NAMES.ajax:
+      return [FEATURE_NAMES.jserrors];
+    case FEATURE_NAMES.sessionTrace:
+      return [FEATURE_NAMES.ajax, FEATURE_NAMES.pageViewEvent];
+    case FEATURE_NAMES.pageViewTiming:
+      return [FEATURE_NAMES.pageViewEvent];
+    // this could change if we disconnect window load timings
+    default:
+      return [];
+  }
+}
+export function getFrozenAttributes(feature) {
+  switch (feature) {
+    // right now, jserrors is the only feature that can have "on" or "off" page-level auto-instrumentation...
+    // page_action is always "off" (no instr)
+    // as new API/manual implementation methods are added, this list can likely be pruned
+    case FEATURE_NAMES.jserrors:
+      return [];
+    default:
+      return ['auto'];
+  }
+}

package/dist/esm/loaders/features/features.js

@@ -0,0 +1,25 @@
+export const FEATURE_NAMES = {
+  ajax: 'ajax',
+  jserrors: 'jserrors',
+  metrics: 'metrics',
+  pageAction: 'page_action',
+  pageViewEvent: 'page_view_event',
+  pageViewTiming: 'page_view_timing',
+  sessionTrace: 'session_trace',
+  spa: 'spa'
+};
+
+/**
+ * The order in which features will be instrumented. This is the traditional order. It's unclear if the order of
+ * wrapping events has any ramifications, so we are enforcing this order intentionally for now.
+ */
+export const featurePriority = {
+  [FEATURE_NAMES.pageViewEvent]: 1,
+  [FEATURE_NAMES.pageViewTiming]: 2,
+  [FEATURE_NAMES.metrics]: 3,
+  [FEATURE_NAMES.jserrors]: 4,
+  [FEATURE_NAMES.ajax]: 5,
+  [FEATURE_NAMES.sessionTrace]: 6,
+  [FEATURE_NAMES.pageAction]: 7,
+  [FEATURE_NAMES.spa]: 8
+};

package/dist/esm/loaders/micro-agent.js

@@ -0,0 +1,91 @@
+// loader files
+import { getEnabledFeatures } from './features/enabled-features';
+import { configure } from './configure/configure';
+// core files
+import { Aggregator } from '../common/aggregate/aggregator';
+import { gosNREUMInitializedAgents } from '../common/window/nreum';
+import { generateRandomHexString } from '../common/ids/unique-id';
+import { getConfiguration, getInfo, getLoaderConfig, getRuntime } from '../common/config/config';
+import { FEATURE_NAMES } from './features/features';
+import { warn } from '../common/util/console';
+const nonAutoFeatures = [FEATURE_NAMES.jserrors, FEATURE_NAMES.pageAction];
+const autoFeatures = [FEATURE_NAMES.metrics];
+
+/**
+ * A minimal agent class designed to be loaded multiple times on the same page, each instance narrowly scoped to the
+ * concerns of a particular component, as with the micro-frontend architectural pattern. This class does not
+ * automatically instrument. Instead, each MicroAgent instance may be configured to lazy-load specific
+ * instrumentations at runtime, and to report desired data, events, and errors programatically.
+ */
+export class MicroAgent {
+  /**
+   * @param {Object} options - Specifies features and runtime configuration,
+   * @param {string=} agentIdentifier - The optional unique ID of the agent.
+   */
+  constructor(options) {
+    let agentIdentifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : generateRandomHexString(16);
+    this.agentIdentifier = agentIdentifier;
+    this.sharedAggregator = new Aggregator({
+      agentIdentifier: this.agentIdentifier
+    });
+    this.features = {};
+    Object.assign(this, configure(this.agentIdentifier, {
+      ...options,
+      runtime: {
+        isolatedBacklog: true
+      }
+    }, options.loaderType || 'micro-agent'));
+    this.start();
+  }
+  get config() {
+    return {
+      info: getInfo(this.agentIdentifier),
+      init: getConfiguration(this.agentIdentifier),
+      loader_config: getLoaderConfig(this.agentIdentifier),
+      runtime: getRuntime(this.agentIdentifier)
+    };
+  }
+  start() {
+    try {
+      const enabledFeatures = getEnabledFeatures(this.agentIdentifier);
+      autoFeatures.forEach(f => {
+        if (enabledFeatures[f]) {
+          // TODO - THIS does not work, the instrument switch in lazy loader increases the size of the worker build.  Needs to be revisited
+          import( /* webpackChunkName: "lazy-loader" */'../features/utils/lazy-loader').then(_ref => {
+            let {
+              lazyLoader
+            } = _ref;
+            return lazyLoader(f, 'instrument');
+          }).then(_ref2 => {
+            let {
+              Instrument
+            } = _ref2;
+            this.features[f] = new Instrument(this.agentIdentifier, this.sharedAggregator);
+          }).catch(err => warn('Something prevented the agent from being downloaded.'));
+        }
+      });
+      nonAutoFeatures.forEach(f => {
+        if (enabledFeatures[f]) {
+          // TODO - THIS does not work, the instrument switch in lazy loader increases the size of the worker build.  Needs to be revisited
+          // Parts of the lazy-loader were removed because webpack was transpiling them into the worker build, errantly inflating the build size.
+          import( /* webpackChunkName: "lazy-loader" */'../features/utils/lazy-loader').then(_ref3 => {
+            let {
+              lazyLoader
+            } = _ref3;
+            return lazyLoader(f, 'aggregate');
+          }).then(_ref4 => {
+            let {
+              Aggregate
+            } = _ref4;
+            this.features[f] = new Aggregate(this.agentIdentifier, this.sharedAggregator);
+          }).catch(err => warn('Something prevented the agent from being downloaded.'));
+        }
+      });
+      gosNREUMInitializedAgents(this.agentIdentifier, this.features, 'features');
+      return this;
+    } catch (err) {
+      warn('Failed to initialize instrument classes.', err);
+      return false;
+    }
+  }
+}

package/dist/esm/loaders/worker-agent.js

@@ -0,0 +1,18 @@
+import { Agent } from './agent';
+import { Instrument as InstrumentMetrics } from '../features/metrics/instrument';
+import { Instrument as InstrumentErrors } from '../features/jserrors/instrument';
+import { Instrument as InstrumentXhr } from '../features/ajax/instrument';
+import { Instrument as InstrumentPageAction } from '../features/page_action/instrument';
+
+/**
+ * A streamlined agent class designed for the service worker context, limited to features relevant in that scope.
+ */
+export class WorkerAgent extends Agent {
+  constructor(args) {
+    super({
+      ...args,
+      features: [InstrumentMetrics, InstrumentErrors, InstrumentXhr, InstrumentPageAction],
+      loaderType: 'worker-agent'
+    });
+  }
+}

package/dist/types/cdn/lite.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lite.d.ts.map

package/dist/types/cdn/lite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lite.d.ts","sourceRoot":"","sources":["../../../src/cdn/lite.js"],"names":[],"mappings":""}

package/dist/types/cdn/polyfills/lite.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lite.d.ts.map

package/dist/types/cdn/polyfills/lite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lite.d.ts","sourceRoot":"","sources":["../../../../src/cdn/polyfills/lite.js"],"names":[],"mappings":""}

package/dist/types/cdn/polyfills/pro.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pro.d.ts.map