@newrelic/browser-agent 0.0.9 → 0.1.229

package/dist/cjs/features/utils/instrument-base.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InstrumentBase = void 0;
+var _drain = require("../../common/drain/drain");
+var _featureBase = require("./feature-base");
+var _load = require("../../common/window/load");
+var _globalScope = require("../../common/util/global-scope");
+var _console = require("../../common/util/console");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * Base class for instrumenting a feature.
+ * @extends FeatureBase
+ */
+class InstrumentBase extends _featureBase.FeatureBase {
+  /**
+   * Instantiate InstrumentBase.
+   * @param {string} agentIdentifier - The unique ID of the instantiated agent (relative to global scope).
+   * @param {Aggregator} aggregator - The shared Aggregator that will handle batching and reporting of data.
+   * @param {string} featureName - The name of the feature module (used to construct file path).
+   * @param {boolean} [auto=true] - Determines whether the feature should automatically register to have the draining
+   *     of its pooled instrumentation data handled by the agent's centralized drain functionality, rather than draining
+   *     immediately. Primarily useful for fine-grained control in tests.
+   */
+  constructor(agentIdentifier, aggregator, featureName, auto = true) {
+    super(agentIdentifier, aggregator, featureName);
+    this.hasAggregator = false;
+    this.auto = auto;
+
+    /** @type {Function | undefined} This should be set by any derived Instrument class if it has things to do when feature fails or is killed. */
+    this.abortHandler;
+    if (auto) (0, _drain.registerDrain)(agentIdentifier, featureName);
+  }
+
+  /**
+   * Lazy-load the latter part of the feature: its aggregator. This method is called by the first part of the feature
+   * (the instrumentation) when instrumentation is complete.
+   */
+  importAggregator() {
+    if (this.hasAggregator || !this.auto) return;
+    this.hasAggregator = true;
+    const importLater = async () => {
+      /**
+       * Note this try-catch differs from the one in Agent.start() in that it's placed later in a page's lifecycle and
+       * it's only responsible for aborting its one specific feature, rather than all.
+       */
+      try {
+        const {
+          lazyLoader
+        } = await Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "lazy-loader" */'./lazy-loader')));
+        const {
+          Aggregate
+        } = await lazyLoader(this.featureName, 'aggregate');
+        new Aggregate(this.agentIdentifier, this.aggregator);
+      } catch (e) {
+        (0, _console.warn)(`Downloading ${this.featureName} failed...`);
+        this.abortHandler?.(); // undo any important alterations made to the page
+
+        // not supported yet but nice to do: "abort" this agent's EE for this feature specifically
+      }
+    };
+
+    // For regular web pages, we want to wait and lazy-load the aggregator only after all page resources are loaded.
+    // Non-browser scopes (i.e. workers) have no `window.load` event, so the aggregator can be lazy-loaded immediately.
+    if (_globalScope.isWorkerScope) importLater();else (0, _load.onWindowLoad)(() => importLater(), true);
+  }
+}
+exports.InstrumentBase = InstrumentBase;

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lazyLoader = lazyLoader;
+var _features = require("../../loaders/features/features");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * 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>}
+ */
+function lazyLoader(featureName, featurePart) {
+  if (featurePart === 'aggregate') {
+    switch (featureName) {
+      case _features.FEATURE_NAMES.ajax:
+        return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "ajax-aggregate" */'../ajax/aggregate')));
+      case _features.FEATURE_NAMES.jserrors:
+        return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "jserrors-aggregate" */'../jserrors/aggregate')));
+      case _features.FEATURE_NAMES.metrics:
+        return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "metrics-aggregate" */'../metrics/aggregate')));
+      case _features.FEATURE_NAMES.pageAction:
+        return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "page_action-aggregate" */'../page_action/aggregate')));
+      case _features.FEATURE_NAMES.pageViewEvent:
+        return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "page_view_event-aggregate" */'../page_view_event/aggregate')));
+      case _features.FEATURE_NAMES.pageViewTiming:
+        return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "page_view_timing-aggregate" */'../page_view_timing/aggregate')));
+      case _features.FEATURE_NAMES.sessionTrace:
+        return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "session_trace-aggregate" */'../session_trace/aggregate')));
+      case _features.FEATURE_NAMES.spa:
+        return Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "spa-aggregate" */'../spa/aggregate')));
+      default:
+        throw new Error(`Attempted to load unsupported agent feature: ${featureName} ${featurePart}`);
+    }
+  }
+}

package/dist/cjs/index.js

@@ -1,59 +1,82 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrowserAgent = void 0;
-const config_1 = require("@newrelic/browser-agent-core/common/config/config");
-const api_1 = require("./utils/api/api");
-const build_configs_1 = require("./utils/config/build-configs");
-const features_1 = require("./utils/features/features");
-const initialize_1 = require("./utils/features/initialize");
-const nreum_1 = require("@newrelic/browser-agent-core/common/window/nreum");
-const unique_id_1 = require("@newrelic/browser-agent-core/common/ids/unique-id");
-const aggregator_1 = require("@newrelic/browser-agent-core/common/aggregate/aggregator");
-class BrowserAgent {
-    constructor() {
-        this._initialized = false;
-        this._id = (0, unique_id_1.generateRandomHexString)(16);
-        this._api = new api_1.Api(this);
-        this._aggregator = new aggregator_1.Aggregator({ agentIdentifier: this._id });
-        this.features = new features_1.Features();
-        this.start = (options) => __awaiter(this, void 0, void 0, function* () {
-            if (this._initialized)
-                return false;
-            this._initialized = true;
-            const { info, config, loader_config } = (0, build_configs_1.buildConfigs)(options);
-            if (info)
-                (0, config_1.setInfo)(this._id, info);
-            if (config)
-                (0, config_1.setConfiguration)(this._id, config);
-            if (loader_config)
-                (0, config_1.setLoaderConfig)(this._id, config);
-            (0, config_1.setRuntime)(this._id, { maxBytes: 30000 });
-            const initializedFeatures = yield (0, initialize_1.initializeFeatures)(this._id, this._api, this._aggregator, this.features);
-            (0, nreum_1.gosNREUMInitializedAgents)(this._id, initializedFeatures, 'features');
-            return true;
-        });
-        this.noticeError = (err, customAttributes) => this._api.noticeError(err, customAttributes);
-    }
-    get config() {
-        return {
-            info: (0, config_1.getInfo)(this._id),
-            config: (0, config_1.getConfiguration)(this._id),
-            loader_config: (0, config_1.getLoaderConfig)(this._id)
-        };
-    }
-    get initialized() { return this._initialized; }
-    ;
-    get id() { return this._id; }
-}
-exports.BrowserAgent = BrowserAgent;
-exports.default = BrowserAgent;
-//# sourceMappingURL=index.js.map
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Ajax", {
+  enumerable: true,
+  get: function () {
+    return _ajax.Ajax;
+  }
+});
+Object.defineProperty(exports, "BrowserAgent", {
+  enumerable: true,
+  get: function () {
+    return _browserAgent.BrowserAgent;
+  }
+});
+Object.defineProperty(exports, "CustomAgent", {
+  enumerable: true,
+  get: function () {
+    return _customAgent.CustomAgent;
+  }
+});
+Object.defineProperty(exports, "JSErrors", {
+  enumerable: true,
+  get: function () {
+    return _jserrors.JSErrors;
+  }
+});
+Object.defineProperty(exports, "Metrics", {
+  enumerable: true,
+  get: function () {
+    return _metrics.Metrics;
+  }
+});
+Object.defineProperty(exports, "PageAction", {
+  enumerable: true,
+  get: function () {
+    return _page_action.PageAction;
+  }
+});
+Object.defineProperty(exports, "PageViewEvent", {
+  enumerable: true,
+  get: function () {
+    return _page_view_event.PageViewEvent;
+  }
+});
+Object.defineProperty(exports, "PageViewTiming", {
+  enumerable: true,
+  get: function () {
+    return _page_view_timing.PageViewTiming;
+  }
+});
+Object.defineProperty(exports, "SessionTrace", {
+  enumerable: true,
+  get: function () {
+    return _session_trace.SessionTrace;
+  }
+});
+Object.defineProperty(exports, "Spa", {
+  enumerable: true,
+  get: function () {
+    return _spa.Spa;
+  }
+});
+Object.defineProperty(exports, "WorkerAgent", {
+  enumerable: true,
+  get: function () {
+    return _workerAgent.WorkerAgent;
+  }
+});
+var _customAgent = require("./custom-agent");
+var _browserAgent = require("./browser-agent");
+var _workerAgent = require("./worker-agent");
+var _ajax = require("./features/ajax");
+var _jserrors = require("./features/jserrors");
+var _metrics = require("./features/metrics");
+var _page_action = require("./features/page_action");
+var _page_view_event = require("./features/page_view_event");
+var _page_view_timing = require("./features/page_view_timing");
+var _session_trace = require("./features/session_trace");
+var _spa = require("./features/spa");

package/dist/cjs/loaders/agent.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Agent = void 0;
+var _enabledFeatures = require("./features/enabled-features");
+var _configure = require("./configure/configure");
+var _featureDependencies = require("./features/featureDependencies");
+var _features = require("./features/features");
+var _instrument = require("../features/page_view_event/instrument");
+var _aggregator = require("../common/aggregate/aggregator");
+var _nreum = require("../common/window/nreum");
+var _uniqueId = require("../common/ids/unique-id");
+var _config = require("../common/config/config");
+var _console = require("../common/util/console");
+var _stringify = require("../common/util/stringify");
+// loader files
+
+// required features
+
+// common files
+
+/**
+ * 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.
+ */
+class Agent {
+  constructor(options, agentIdentifier = (0, _uniqueId.generateRandomHexString)(16)) {
+    this.agentIdentifier = agentIdentifier;
+    this.sharedAggregator = new _aggregator.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(_instrument.Instrument);
+    Object.assign(this, (0, _configure.configure)(this.agentIdentifier, options, options.loaderType || 'agent'));
+    this.start();
+  }
+  get config() {
+    return {
+      info: (0, _config.getInfo)(this.agentIdentifier),
+      init: (0, _config.getConfiguration)(this.agentIdentifier),
+      loader_config: (0, _config.getLoaderConfig)(this.agentIdentifier),
+      runtime: (0, _config.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 = (0, _enabledFeatures.getEnabledFeatures)(this.agentIdentifier);
+      const featuresToStart = Array.from(this.desiredFeatures);
+      featuresToStart.sort((a, b) => _features.featurePriority[a.featureName] - _features.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 === _features.FEATURE_NAMES.pageViewEvent) {
+          const dependencies = (0, _featureDependencies.getFeatureDependencyNames)(f.featureName);
+          const hasAllDeps = dependencies.every(x => enabledFeatures[x]);
+          if (!hasAllDeps) (0, _console.warn)(`${f.featureName} is enabled but one or more dependent features has been disabled (${(0, _stringify.stringify)(dependencies)}). This may cause unintended consequences or missing data...`);
+          this.features[f.featureName] = new f(this.agentIdentifier, this.sharedAggregator);
+        }
+      });
+      (0, _nreum.gosNREUMInitializedAgents)(this.agentIdentifier, this.features, NR_FEATURES_REF_NAME);
+    } catch (err) {
+      (0, _console.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 = (0, _nreum.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;
+    }
+  }
+}
+exports.Agent = Agent;

package/dist/cjs/loaders/api/api.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setAPI = setAPI;
+var _lodash = _interopRequireDefault(require("lodash._slice"));
+var _features = require("../features/features");
+var _config = require("../../common/config/config");
+var _handle = require("../../common/event-emitter/handle");
+var _mapOwn = require("../../common/util/map-own");
+var _contextualEe = require("../../common/event-emitter/contextual-ee");
+var _now = require("../../common/timing/now");
+var _drain = require("../../common/drain/drain");
+var _load = require("../../common/window/load");
+var _globalScope = require("../../common/util/global-scope");
+var _console = require("../../common/util/console");
+var _constants = require("../../features/metrics/constants");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function setAPI(agentIdentifier, forceDrain) {
+  if (!forceDrain) (0, _drain.registerDrain)(agentIdentifier, 'api');
+  const apiInterface = {};
+  var instanceEE = _contextualEe.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.
+  (0, _mapOwn.mapOwn)(asyncApiFns, function (num, fnName) {
+    apiInterface[fnName] = apiCall(prefix, fnName, true, 'api');
+  });
+  apiInterface.addPageAction = apiCall(prefix, 'addPageAction', true, _features.FEATURE_NAMES.pageAction);
+  apiInterface.setCurrentRouteName = apiCall(prefix, 'routeName', true, _features.FEATURE_NAMES.spa);
+  apiInterface.setPageViewName = function (name, host) {
+    if (typeof name !== 'string') return;
+    if (name.charAt(0) !== '/') name = '/' + name;
+    (0, _config.getRuntime)(agentIdentifier).customTransaction = (host || 'http://custom.transaction') + name;
+    return apiCall(prefix, 'setPageViewName', true, 'api')();
+  };
+  apiInterface.setCustomAttribute = function (name, value) {
+    const currentInfo = (0, _config.getInfo)(agentIdentifier);
+    (0, _config.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';
+      (0, _handle.handle)(spaPrefix + 'tracer', [(0, _now.now)(), name, contextStore], ixn, _features.FEATURE_NAMES.spa, instanceEE);
+      return function () {
+        tracerEE.emit((hasCb ? '' : 'no-') + 'fn-start', [(0, _now.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', [(0, _now.now)()], contextStore);
+          }
+        }
+      };
+    }
+  };
+  (0, _mapOwn.mapOwn)('actionText,setName,setAttribute,save,ignore,onEnd,getContext,end,get'.split(','), function addApi(n, name) {
+    InteractionApiProto[name] = apiCall(spaPrefix, name, undefined, _features.FEATURE_NAMES.spa);
+  });
+  function apiCall(prefix, name, notSpa, bufferGroup) {
+    return function () {
+      (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/' + name + '/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
+      (0, _handle.handle)(prefix + name, [(0, _now.now)()].concat((0, _lodash.default)(arguments)), notSpa ? null : this, bufferGroup, instanceEE);
+      return notSpa ? void 0 : this;
+    };
+  }
+  apiInterface.noticeError = function (err, customAttributes) {
+    if (typeof err === 'string') err = new Error(err);
+    (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['API/noticeError/called'], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
+    (0, _handle.handle)('err', [err, (0, _now.now)(), false, customAttributes], undefined, _features.FEATURE_NAMES.jserrors, instanceEE);
+  };
+
+  // theres no window.load event on non-browser scopes, lazy load immediately
+  if (_globalScope.isWorkerScope) lazyLoad();
+  // try to stay out of the way of the window.load event, lazy load once that has finished.
+  else (0, _load.onWindowLoad)(() => lazyLoad(), true);
+  function lazyLoad() {
+    Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "async-api" */'./apiAsync'))).then(({
+      setAPI
+    }) => {
+      setAPI(agentIdentifier);
+      (0, _drain.drain)(agentIdentifier, 'api');
+    }).catch(() => (0, _console.warn)('Downloading runtime APIs failed...'));
+  }
+  return apiInterface;
+}

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

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setAPI = setAPI;
+var _features = require("../features/features");
+var _config = require("../../common/config/config");
+var _contextualEe = require("../../common/event-emitter/contextual-ee");
+var _handle = require("../../common/event-emitter/handle");
+var _registerHandler = require("../../common/event-emitter/register-handler");
+var _mapOwn = require("../../common/util/map-own");
+var _single = require("../../common/util/single");
+var _submitData = require("../../common/util/submit-data");
+var _globalScope = require("../../common/util/global-scope");
+var _constants = require("../../features/metrics/constants");
+function setAPI(agentIdentifier) {
+  var instanceEE = _contextualEe.ee.get(agentIdentifier);
+  var cycle = 0;
+  var scheme = (0, _config.getConfigurationValue)(agentIdentifier, 'ssl') === false ? 'http' : 'https';
+  var api = {
+    finished: (0, _single.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
+  (0, _mapOwn.mapOwn)(api, function (fnName, fn) {
+    (0, _registerHandler.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 - (0, _config.getRuntime)(agentIdentifier).offset : t;
+    (0, _handle.handle)(_constants.CUSTOM_METRIC_CHANNEL, ['finished', {
+      time
+    }], undefined, _features.FEATURE_NAMES.metrics, instanceEE);
+    addToTrace(t, {
+      name: 'finished',
+      start: time + (0, _config.getRuntime)(agentIdentifier).offset,
+      origin: 'nr'
+    });
+    (0, _handle.handle)('api-addPageAction', [time, 'finished'], undefined, _features.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 - (0, _config.getRuntime)(agentIdentifier).offset,
+      e: (evt.end || evt.start) - (0, _config.getRuntime)(agentIdentifier).offset,
+      o: evt.origin || '',
+      t: 'api'
+    };
+    (0, _handle.handle)('bstApi', [report], undefined, _features.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 (!_globalScope.isBrowserScope) return;
+    request_name = window.encodeURIComponent(request_name);
+    cycle += 1;
+    const agentInfo = (0, _config.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.submitData.img(url);
+  }
+  function setErrorHandler(t, handler) {
+    (0, _config.getRuntime)(agentIdentifier).onerror = handler;
+  }
+  var releaseCount = 0;
+  function addRelease(t, name, id) {
+    if (++releaseCount > 10) return;
+    (0, _config.getRuntime)(agentIdentifier).releaseIds[name.slice(-200)] = ('' + id).slice(-200);
+  }
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BrowserAgent = void 0;
+var _agent = require("./agent");
+var _instrument = require("../features/page_view_event/instrument");
+var _instrument2 = require("../features/page_view_timing/instrument");
+var _instrument3 = require("../features/metrics/instrument");
+var _instrument4 = require("../features/jserrors/instrument");
+var _instrument5 = require("../features/ajax/instrument");
+var _instrument6 = require("../features/session_trace/instrument");
+var _instrument7 = require("../features/spa/instrument");
+var _instrument8 = require("../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.
+ */
+class BrowserAgent extends _agent.Agent {
+  constructor(args) {
+    super({
+      ...args,
+      features: [_instrument5.Instrument, _instrument.Instrument, _instrument2.Instrument, _instrument6.Instrument, _instrument3.Instrument, _instrument8.Instrument, _instrument4.Instrument, _instrument7.Instrument],
+      loaderType: 'browser-agent'
+    });
+  }
+}
+exports.BrowserAgent = BrowserAgent;

package/dist/cjs/loaders/configure/configure.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configure = configure;
+var _api = require("../api/api");
+var _nreum = require("../../common/window/nreum");
+var _config = require("../../common/config/config");
+var _featureFlags = require("../../common/util/feature-flags");
+var _globalScope = require("../../common/util/global-scope");
+var _topLevelCallers = require("../../common/window/top-level-callers");
+function configure(agentIdentifier, opts = {}, loaderType, forceDrain) {
+  let {
+    init,
+    info,
+    loader_config,
+    runtime = {
+      loaderType
+    },
+    exposed = true
+  } = opts;
+  const nr = (0, _nreum.gosCDN)();
+  if (!info) {
+    init = nr.init;
+    info = nr.info;
+    loader_config = nr.loader_config;
+  }
+  if (_globalScope.isWorkerScope) {
+    // add a default attr to all worker payloads
+    info.jsAttributes = {
+      ...info.jsAttributes,
+      isWorker: true
+    };
+  }
+  (0, _config.setInfo)(agentIdentifier, info);
+  (0, _config.setConfiguration)(agentIdentifier, init || {});
+  (0, _config.setLoaderConfig)(agentIdentifier, loader_config || {});
+  (0, _config.setRuntime)(agentIdentifier, runtime);
+  (0, _topLevelCallers.setTopLevelCallers)();
+  const api = (0, _api.setAPI)(agentIdentifier, forceDrain);
+  (0, _nreum.gosNREUMInitializedAgents)(agentIdentifier, api, 'api');
+  (0, _nreum.gosNREUMInitializedAgents)(agentIdentifier, exposed, 'exposed');
+  (0, _nreum.addToNREUM)('activatedFeatures', _featureFlags.activatedFeatures);
+  (0, _nreum.addToNREUM)('setToken', flags => (0, _featureFlags.activateFeatures)(flags, agentIdentifier));
+  return api;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnabledFeatures = getEnabledFeatures;
+var _features = require("./features");
+var _config = require("../../common/config/config");
+const featureNames = Object.values(_features.FEATURE_NAMES);
+function isEnabled(name, agentIdentifier) {
+  return (0, _config.getConfigurationValue)(agentIdentifier, `${name}.enabled`) !== false;
+}
+function getEnabledFeatures(agentIdentifier) {
+  const enabledFeatures = {};
+  featureNames.forEach(featureName => {
+    enabledFeatures[featureName] = isEnabled(featureName, agentIdentifier);
+  });
+  return enabledFeatures;
+}