@newrelic/browser-agent 0.0.9 → 0.1.230

package/dist/cjs/common/browser-version/firefox-version.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ffVersion = void 0;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable no-useless-escape */
+
+var ffVersion = 0;
+exports.ffVersion = ffVersion;
+var match = navigator.userAgent.match(/Firefox[\/\s](\d+\.\d+)/);
+if (match) exports.ffVersion = ffVersion = +match[1];

package/dist/cjs/common/browser-version/ios-version.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isiOS = exports.iOS_below16 = void 0;
+const isiOS = /(iPad|iPhone|iPod)/g.test(navigator.userAgent);
+
+/* Feature detection to get our version(s). */
+
+// Shared Web Workers introduced in iOS 16.0+ and n/a in 15.6-
+exports.isiOS = isiOS;
+const iOS_below16 = isiOS && Boolean(typeof SharedWorker === 'undefined');
+/* ^ It was discovered in Safari 14 (https://bugs.webkit.org/show_bug.cgi?id=225305) that the buffered flag in PerformanceObserver
+	did not work. This affects our onFCP metric in particular since web-vitals uses that flag to retrieve paint timing entries.
+	This was fixed in v16+.
+*/
+exports.iOS_below16 = iOS_below16;

package/dist/cjs/common/config/config.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "getConfiguration", {
+  enumerable: true,
+  get: function () {
+    return _init.getConfiguration;
+  }
+});
+Object.defineProperty(exports, "getConfigurationValue", {
+  enumerable: true,
+  get: function () {
+    return _init.getConfigurationValue;
+  }
+});
+Object.defineProperty(exports, "getInfo", {
+  enumerable: true,
+  get: function () {
+    return _info.getInfo;
+  }
+});
+Object.defineProperty(exports, "getLoaderConfig", {
+  enumerable: true,
+  get: function () {
+    return _loaderConfig.getLoaderConfig;
+  }
+});
+Object.defineProperty(exports, "getRuntime", {
+  enumerable: true,
+  get: function () {
+    return _runtime.getRuntime;
+  }
+});
+exports.isConfigured = isConfigured;
+Object.defineProperty(exports, "originals", {
+  enumerable: true,
+  get: function () {
+    return _originals.originals;
+  }
+});
+Object.defineProperty(exports, "setConfiguration", {
+  enumerable: true,
+  get: function () {
+    return _init.setConfiguration;
+  }
+});
+Object.defineProperty(exports, "setInfo", {
+  enumerable: true,
+  get: function () {
+    return _info.setInfo;
+  }
+});
+Object.defineProperty(exports, "setLoaderConfig", {
+  enumerable: true,
+  get: function () {
+    return _loaderConfig.setLoaderConfig;
+  }
+});
+Object.defineProperty(exports, "setRuntime", {
+  enumerable: true,
+  get: function () {
+    return _runtime.setRuntime;
+  }
+});
+var _info = require("./state/info");
+var _init = require("./state/init");
+var _loaderConfig = require("./state/loader-config");
+var _originals = require("./state/originals");
+var _runtime = require("./state/runtime");
+function isConfigured(agentIdentifier) {
+  return (0, _info.isValid)(agentIdentifier);
+}
+
+// This module acts as a hub that bundles the static and dynamic properties used by each agent instance into one single interface

package/dist/cjs/common/config/state/configurable.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Configurable = void 0;
+var _featureDependencies = require("../../../loaders/features/featureDependencies");
+var _console = require("../../util/console");
+class Configurable {
+  constructor(obj, model) {
+    try {
+      if (!obj || typeof obj !== 'object') return (0, _console.warn)('New setting a Configurable requires an object as input');
+      if (!model || typeof model !== 'object') return (0, _console.warn)('Setting a Configurable requires a model to set its initial properties');
+      Object.assign(this, model);
+      Object.entries(obj).forEach(_ref => {
+        let [key, value] = _ref;
+        const frozenAttrs = (0, _featureDependencies.getFrozenAttributes)(key);
+        if (frozenAttrs.length && value && typeof value === 'object') {
+          frozenAttrs.forEach(attr => {
+            if (attr in value) {
+              (0, _console.warn)(`"${attr}" is a protected attribute and can not be changed in feature ${key}.  It will have no effect.`);
+              delete value[attr];
+            }
+          });
+        }
+        this[key] = value;
+      });
+    } catch (err) {
+      (0, _console.warn)('An error occured while setting a Configurable', err);
+    }
+  }
+}
+exports.Configurable = Configurable;

package/dist/cjs/common/config/state/info.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInfo = getInfo;
+exports.isValid = isValid;
+exports.setInfo = setInfo;
+var _nreum = require("../../window/nreum");
+var _configurable = require("./configurable");
+const model = {
+  // preset defaults
+  beacon: _nreum.defaults.beacon,
+  errorBeacon: _nreum.defaults.errorBeacon,
+  // others must be populated by user
+  licenseKey: undefined,
+  applicationID: undefined,
+  sa: undefined,
+  queueTime: undefined,
+  applicationTime: undefined,
+  ttGuid: undefined,
+  user: undefined,
+  account: undefined,
+  product: undefined,
+  extra: undefined,
+  jsAttributes: {},
+  userAttributes: undefined,
+  atts: undefined,
+  transactionName: undefined,
+  tNamePlain: undefined
+};
+const _cache = {};
+function isValid(id) {
+  try {
+    const info = getInfo(id);
+    return !!info.licenseKey && !!info.errorBeacon && !!info.applicationID;
+  } catch (err) {
+    return false;
+  }
+}
+function getInfo(id) {
+  if (!id) throw new Error('All info objects require an agent identifier!');
+  if (!_cache[id]) throw new Error(`Info for ${id} was never set`);
+  return _cache[id];
+}
+function setInfo(id, obj) {
+  if (!id) throw new Error('All info objects require an agent identifier!');
+  _cache[id] = new _configurable.Configurable(obj, model);
+  (0, _nreum.gosNREUMInitializedAgents)(id, _cache[id], 'info');
+}

package/dist/cjs/common/config/state/init.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfiguration = getConfiguration;
+exports.getConfigurationValue = getConfigurationValue;
+exports.setConfiguration = setConfiguration;
+var _nreum = require("../../window/nreum");
+var _configurable = require("./configurable");
+const model = {
+  allow_bfcache: true,
+  // *cli - temporary feature flag for BFCache work
+  privacy: {
+    cookies_enabled: true
+  },
+  // *cli - per discussion, default should be true
+  ajax: {
+    deny_list: undefined,
+    enabled: true,
+    harvestTimeSeconds: 10
+  },
+  distributed_tracing: {
+    enabled: undefined,
+    exclude_newrelic_header: undefined,
+    cors_use_newrelic_header: undefined,
+    cors_use_tracecontext_headers: undefined,
+    allowed_origins: undefined
+  },
+  ssl: undefined,
+  obfuscate: undefined,
+  jserrors: {
+    enabled: true,
+    harvestTimeSeconds: 10
+  },
+  metrics: {
+    enabled: true
+  },
+  page_action: {
+    enabled: true,
+    harvestTimeSeconds: 30
+  },
+  page_view_event: {
+    enabled: true
+  },
+  page_view_timing: {
+    enabled: true,
+    harvestTimeSeconds: 30,
+    long_task: false
+  },
+  session_trace: {
+    enabled: true,
+    harvestTimeSeconds: 10
+  },
+  spa: {
+    enabled: true,
+    harvestTimeSeconds: 10
+  }
+};
+const _cache = {};
+function getConfiguration(id) {
+  if (!id) throw new Error('All configuration objects require an agent identifier!');
+  if (!_cache[id]) throw new Error(`Configuration for ${id} was never set`);
+  return _cache[id];
+}
+function setConfiguration(id, obj) {
+  if (!id) throw new Error('All configuration objects require an agent identifier!');
+  _cache[id] = new _configurable.Configurable(obj, model);
+  (0, _nreum.gosNREUMInitializedAgents)(id, _cache[id], 'config');
+}
+function getConfigurationValue(id, path) {
+  if (!id) throw new Error('All configuration objects require an agent identifier!');
+  var val = getConfiguration(id);
+  if (val) {
+    var parts = path.split('.');
+    for (var i = 0; i < parts.length - 1; i++) {
+      val = val[parts[i]];
+      if (typeof val !== 'object') return;
+    }
+    val = val[parts[parts.length - 1]];
+  }
+  return val;
+}
+
+// TO DO: a setConfigurationValue equivalent may be nice so individual
+//  properties can be tuned instead of reseting the whole model per call to `setConfiguration(agentIdentifier, {})`

package/dist/cjs/common/config/state/loader-config.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLoaderConfig = getLoaderConfig;
+exports.setLoaderConfig = setLoaderConfig;
+var _nreum = require("../../window/nreum");
+var _configurable = require("./configurable");
+const model = {
+  accountID: undefined,
+  trustKey: undefined,
+  agentID: undefined,
+  licenseKey: undefined,
+  applicationID: undefined,
+  xpid: undefined
+};
+const _cache = {};
+function getLoaderConfig(id) {
+  if (!id) throw new Error('All loader-config objects require an agent identifier!');
+  if (!_cache[id]) throw new Error(`LoaderConfig for ${id} was never set`);
+  return _cache[id];
+}
+function setLoaderConfig(id, obj) {
+  if (!id) throw new Error('All loader-config objects require an agent identifier!');
+  _cache[id] = new _configurable.Configurable(obj, model);
+  (0, _nreum.gosNREUMInitializedAgents)(id, _cache[id], 'loader_config');
+}

package/dist/cjs/common/config/state/originals.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.originals = void 0;
+var _nreum = require("../../window/nreum");
+const originals = (0, _nreum.gosNREUMOriginals)().o;
+exports.originals = originals;

package/dist/cjs/common/config/state/runtime.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRuntime = getRuntime;
+exports.setRuntime = setRuntime;
+var userAgent = _interopRequireWildcard(require("../../util/user-agent"));
+var _configurable = require("./configurable");
+var _nreum = require("../../window/nreum");
+var _sessionStorage = require("../../window/session-storage");
+var _config = require("../config");
+var _globalScope = require("../../util/global-scope");
+var _environmentVariables = require("../../constants/environment-variables");
+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; }
+const model = agentId => {
+  return {
+    buildEnv: _environmentVariables.BUILD_ENV,
+    bytesSent: {},
+    customTransaction: undefined,
+    disabled: false,
+    distMethod: _environmentVariables.DIST_METHOD,
+    isolatedBacklog: false,
+    loaderType: undefined,
+    maxBytes: 30000,
+    // The "timeOrigin" property is the new standard timestamp property shared across main frame and workers, but is not supported in some early Safari browsers (safari<15) + IE
+    // ingest expects an integer value, and timeOrigin can return a float.
+    offset: Math.floor(_globalScope.globalScope?.performance?.timeOrigin || _globalScope.globalScope?.performance?.timing?.navigationStart || Date.now()),
+    onerror: undefined,
+    origin: '' + _globalScope.globalScope.location,
+    ptid: undefined,
+    releaseIds: {},
+    sessionId: (0, _config.getConfigurationValue)(agentId, 'privacy.cookies_enabled') == true ? (0, _sessionStorage.getCurrentSessionIdOrMakeNew)() : null,
+    // if cookies (now session tracking) is turned off or can't get session ID, this is null
+    xhrWrappable: typeof _globalScope.globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
+    userAgent,
+    version: _environmentVariables.VERSION
+  };
+};
+const _cache = {};
+function getRuntime(id) {
+  if (!id) throw new Error('All runtime objects require an agent identifier!');
+  if (!_cache[id]) throw new Error(`Runtime for ${id} was never set`);
+  return _cache[id];
+}
+function setRuntime(id, obj) {
+  if (!id) throw new Error('All runtime objects require an agent identifier!');
+  _cache[id] = new _configurable.Configurable(obj, model(id));
+  (0, _nreum.gosNREUMInitializedAgents)(id, _cache[id], 'runtime');
+}

package/dist/cjs/common/constants/environment-variables.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
+// Webpack and NPM builds define `process.env.BUILD_VERSION` at build time based on variables supplied at build time.
+// VERSION as defined here ends up decorating: agent runtime configuration, harvest, and supportability metrics.
+const VERSION = typeof "0.1.230" !== 'undefined' && "0.1.230" || '';
+
+// process.env.BUILD_ENV is replaced during webpack -or- npm build with environment vars supplied at build time
+// LOCAL, PROD, DEV, etc
+exports.VERSION = VERSION;
+const BUILD_ENV = typeof "NPM" !== 'undefined' && "NPM" || '';
+
+// process.env.DIST_METHOD is replaced during webpack -or- npm build with environment vars supplied at build time
+// CDN, NPM etc
+exports.BUILD_ENV = BUILD_ENV;
+const DIST_METHOD = typeof "NPM" !== 'undefined' && "NPM" || '';
+exports.DIST_METHOD = DIST_METHOD;

package/dist/cjs/common/context/shared-context.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SharedContext = void 0;
+var _console = require("../util/console");
+const model = {
+  agentIdentifier: ''
+};
+class SharedContext {
+  constructor(context) {
+    try {
+      if (typeof context !== 'object') return (0, _console.warn)('shared context requires an object as input');
+      this.sharedContext = {};
+      Object.assign(this.sharedContext, model);
+      Object.entries(context).forEach(_ref => {
+        let [key, value] = _ref;
+        if (Object.keys(model).includes(key)) this.sharedContext[key] = value;
+      });
+    } catch (err) {
+      (0, _console.warn)('An error occured while setting SharedContext', err);
+    }
+  }
+}
+exports.SharedContext = SharedContext;

package/dist/cjs/common/deny-list/deny-list.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setDenyList = setDenyList;
+exports.shouldCollectEvent = shouldCollectEvent;
+/** An array of filter objects {hostname, pathname} for identifying XHR events to be excluded from collection.
+ * @see {@link https://docs.newrelic.com/docs/browser/new-relic-browser/configuration/filter-ajax-request-events/ Filter AjaxRequest events}
+ * @type {Array.<{hostname: string, pathname: string}>}
+ */
+var denyList = [];
+
+/**
+ * Evaluates whether an XHR event should be included for collection based on the {@link denyList|AjaxRequest deny list}.
+ * @param {Object} params - object with properties of the XHR event
+ * @returns {boolean} `true` if request does not match any entries of {@link denyList|deny list}; else `false`
+ */
+function shouldCollectEvent(params) {
+  if (denyList.length === 0) {
+    return true;
+  }
+
+  // XHR requests with an undefined hostname (e.g., data URLs) should not be collected.
+  if (params.hostname === undefined) {
+    return false;
+  }
+  for (var i = 0; i < denyList.length; i++) {
+    var parsed = denyList[i];
+    if (parsed.hostname === '*') {
+      return false;
+    }
+    if (domainMatchesPattern(parsed.hostname, params.hostname) && comparePath(parsed.pathname, params.pathname)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Initializes the {@link denyList|XHR deny list} by extracting hostname and pathname from an array of filter strings.
+ * @param {string[]} denyListConfig - array of URL filters to identify XHR requests to be excluded from collection
+ */
+function setDenyList(denyListConfig) {
+  denyList = [];
+  if (!denyListConfig || !denyListConfig.length) {
+    return;
+  }
+  for (var i = 0; i < denyListConfig.length; i++) {
+    var url = denyListConfig[i];
+    if (url.indexOf('http://') === 0) {
+      url = url.substring(7);
+    } else if (url.indexOf('https://') === 0) {
+      url = url.substring(8);
+    }
+    var firstSlash = url.indexOf('/');
+    if (firstSlash > 0) {
+      denyList.push({
+        hostname: url.substring(0, firstSlash),
+        pathname: url.substring(firstSlash)
+      });
+    } else {
+      denyList.push({
+        hostname: url,
+        pathname: ''
+      });
+    }
+  }
+}
+/**
+ * Returns true if the right side of `domain` (end of string) matches `pattern`.
+ * @param {string} pattern - a string to be matched against the end of `domain` string
+ * @param {string} domain - a domain string with no protocol or path (e.g., app1.example.com)
+ * @returns {boolean} `true` if domain matches pattern; else `false`
+ */
+function domainMatchesPattern(pattern, domain) {
+  if (pattern.length > domain.length) {
+    return false;
+  }
+  if (domain.indexOf(pattern) === domain.length - pattern.length) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Returns true if a URL path matches a pattern string, disregarding leading slashes.
+ * @param {string} pattern - a string to compare with path (e.g., api/v1)
+ * @param {string} path - a string representing a URL path (e.g., /api/v1)
+ * @returns {boolean} `true` if path and pattern are an exact string match (except for leading slashes); else `false`
+ */
+function comparePath(pattern, path) {
+  if (pattern.indexOf('/') === 0) {
+    pattern = pattern.substring(1);
+  }
+  if (path.indexOf('/') === 0) {
+    path = path.substring(1);
+  }
+
+  // No path in pattern means match all paths.
+  if (pattern === '') {
+    return true;
+  }
+  if (pattern === path) {
+    return true;
+  }
+  return false;
+}

package/dist/cjs/common/drain/drain.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.drain = drain;
+exports.registerDrain = registerDrain;
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _mapOwn = require("../util/map-own");
+var _registerHandler = require("../event-emitter/register-handler");
+var _features = require("../../loaders/features/features");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const registry = {};
+
+/**
+ * Adds an entry to the centralized drain registry specifying that a particular agent has events of a particular named
+ * event-group "bucket" that should be drained at the time the agent drains all its buffered events. Buffered events
+ * accumulate because instrumentation begins as soon as possible, before the agent has finished lazy-loading the code
+ * responsible for aggregating and reporting captured data.
+ * @param {string} agentIdentifier - A 16 character string uniquely identifying the agent.
+ * @param {string} group - The named "bucket" for the events this feature will be bucketing for later collection.
+ */
+function registerDrain(agentIdentifier, group) {
+  // Here `item` captures the registered properties of a feature-group: whether it is ready for its buffered events
+  // to be drained (`staged`) and the `priority` order in which it should be drained relative to other feature groups.
+  const item = {
+    staged: false,
+    priority: _features.featurePriority[group] || 0
+  };
+  curateRegistry(agentIdentifier);
+  if (!registry[agentIdentifier].get(group)) registry[agentIdentifier].set(group, item);
+}
+
+/**
+ * Registers the specified agent with the centralized event buffer registry if it is not already registered.
+ * Agents without an identifier (as in the case of some tests) will be excluded from the registry.
+ * @param {string} agentIdentifier - A 16 character string uniquely identifying an agent.
+ */
+function curateRegistry(agentIdentifier) {
+  if (!agentIdentifier) return;
+  if (!registry[agentIdentifier]) registry[agentIdentifier] = new Map();
+}
+
+/**
+ * Drain buffered events out of the event emitter. Each feature should have its events bucketed by "group" and drain
+ * its own named group explicitly, when ready.
+ * @param {string} agentIdentifier - A unique 16 character ID corresponding to an instantiated agent.
+ * @param {string} featureName - A named group into which the feature's buffered events are bucketed.
+ */
+function drain() {
+  let agentIdentifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let featureName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'feature';
+  curateRegistry(agentIdentifier);
+
+  // If the feature for the specified agent is not in the registry, that means the instrument file was bypassed.
+  // This could happen in tests, or loaders that directly import the aggregator. In these cases it is safe to
+  // drain the feature group immediately rather than waiting to drain all at once.
+  if (!agentIdentifier || !registry[agentIdentifier].get(featureName)) return drainGroup(featureName);
+
+  // When `drain` is called, this feature is ready to drain (staged).
+  registry[agentIdentifier].get(featureName).staged = true;
+
+  // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
+  // that the last feature to call drain triggers drain for all features.
+  const items = Array.from(registry[agentIdentifier]);
+  if (items.every(_ref => {
+    let [key, values] = _ref;
+    return values.staged;
+  })) {
+    items.sort((a, b) => a[1].priority - b[1].priority);
+    items.forEach(_ref2 => {
+      let [group] = _ref2;
+      drainGroup(group);
+    });
+  }
+
+  /**
+   * Drains all the buffered (backlog) events for a particular feature's event-group by emitting each event to each of
+   * the subscribed handlers for the group.
+   * @param {*} group - The name of a particular feature's event "bucket".
+   */
+  function drainGroup(group) {
+    const baseEE = agentIdentifier ? _contextualEe.ee.get(agentIdentifier) : _contextualEe.ee;
+    const handlers = _registerHandler.registerHandler.handlers;
+    if (!baseEE.backlog || !handlers) return;
+    var bufferedEventsInGroup = baseEE.backlog[group];
+    var groupHandlers = handlers[group];
+    if (groupHandlers) {
+      // We don't cache the length of the buffer while looping because events might still be added while processing.
+      for (var i = 0; bufferedEventsInGroup && i < bufferedEventsInGroup.length; ++i) {
+        // eslint-disable-line no-unmodified-loop-condition
+        emitEvent(bufferedEventsInGroup[i], groupHandlers);
+      }
+      (0, _mapOwn.mapOwn)(groupHandlers, function (eventType, handlerRegistrationList) {
+        (0, _mapOwn.mapOwn)(handlerRegistrationList, function (i, registration) {
+          // registration is an array of: [targetEE, eventHandler]
+          registration[0].on(eventType, registration[1]);
+        });
+      });
+    }
+    delete handlers[group];
+
+    // Keep the feature's event-group as a property of the event emitter so we know it was already created and drained.
+    baseEE.backlog[group] = null;
+    baseEE.emit('drain-' + group, []);
+  }
+}
+
+/**
+ * Processes the specified event using all relevant handler functions associated with a particular feature, based on
+ * whether the the handler is meant to apply to events of this type. (Event type is a descriptive string set at the
+ * time an event is originally created by instrumentation, as with calls to the `handle` method.)
+ * @param {*} evt - A single event to be emitted to (processed by) eligible handler functions.
+ * @param {*} groupHandlers - A set of handler functions associated with a particular feature's event-group.
+ */
+function emitEvent(evt, groupHandlers) {
+  var type = evt[1];
+  (0, _mapOwn.mapOwn)(groupHandlers[type], function (i, registration) {
+    var sourceEE = evt[0];
+    var ee = registration[0];
+    if (ee === sourceEE) {
+      var handler = registration[1];
+      var ctx = evt[3];
+      var args = evt[2];
+      handler.apply(ctx, args);
+    }
+  });
+}