@newrelic/browser-agent 0.0.9 → 0.1.229

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 { CustomAgent } from './custom-agent';
+export { BrowserAgent } from './browser-agent';
+export { WorkerAgent } from './worker-agent';
+
+/** IN-PROGRESS -- DOES NOT CURRENTLY WORK CORRECTLY */
+// export { MicroAgent } from './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,77 @@
+// 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, agentIdentifier = 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,104 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import slice from 'lodash._slice';
+import { FEATURE_NAMES } from '../features/features';
+import { getRuntime, setInfo, getInfo } from '../../common/config/config';
+import { handle } from '../../common/event-emitter/handle';
+import { mapOwn } from '../../common/util/map-own';
+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 { isWorkerScope } from '../../common/util/global-scope';
+import { warn } from '../../common/util/console';
+import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants';
+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.
+  mapOwn(asyncApiFns, function (num, 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, 'api')();
+  };
+  apiInterface.setCustomAttribute = function (name, value) {
+    const currentInfo = getInfo(agentIdentifier);
+    setInfo(agentIdentifier, {
+      ...currentInfo,
+      jsAttributes: {
+        ...currentInfo.jsAttributes,
+        [name]: value
+      }
+    });
+    return apiCall(prefix, 'setCustomAttribute', true, 'api')();
+  };
+  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);
+          }
+        }
+      };
+    }
+  };
+  mapOwn('actionText,setName,setAttribute,save,ignore,onEnd,getContext,end,get'.split(','), function addApi(n, 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);
+      handle(prefix + name, [now()].concat(slice(arguments)), notSpa ? null : this, bufferGroup, instanceEE);
+      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(({
+      setAPI
+    }) => {
+      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 { mapOwn } from '../../common/util/map-own';
+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
+  mapOwn(api, function (fnName, fn) {
+    registerHandler('api-' + fnName, fn, '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,41 @@
+import { setAPI } 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 { isWorkerScope } from '../../common/util/global-scope';
+import { setTopLevelCallers } from '../../common/window/top-level-callers';
+export function configure(agentIdentifier, opts = {}, loaderType, forceDrain) {
+  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;
+  }
+  if (isWorkerScope) {
+    // add a default attr to all worker payloads
+    info.jsAttributes = {
+      ...info.jsAttributes,
+      isWorker: true
+    };
+  }
+  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,86 @@
+// 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, agentIdentifier = 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(({
+            lazyLoader
+          }) => {
+            return lazyLoader(f, 'instrument');
+          }).then(({
+            Instrument
+          }) => {
+            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(({
+            lazyLoader
+          }) => {
+            return lazyLoader(f, 'aggregate');
+          }).then(({
+            Aggregate
+          }) => {
+            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'
+    });
+  }
+}