@newrelic/browser-agent 0.1.229 → 0.1.230

package/src/common/aggregate/aggregator.js

@@ -0,0 +1,171 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { SharedContext } from '../context/shared-context'
+import { mapOwn } from '../util/map-own'
+
+export class Aggregator extends SharedContext {
+  constructor (parent) {
+    super(parent)
+    this.aggregatedData = {}
+  }
+
+  // Items with the same type and name get aggregated together
+  // params are example data from the aggregated items
+  // metrics are the numeric values to be aggregated
+
+  store (type, name, params, newMetrics, customParams) {
+    var bucket = this.getBucket(type, name, params, customParams)
+    bucket.metrics = aggregateMetrics(newMetrics, bucket.metrics)
+    return bucket
+  }
+
+  merge (type, name, metrics, params, customParams) {
+    var bucket = this.getBucket(type, name, params, customParams)
+
+    if (!bucket.metrics) {
+      bucket.metrics = metrics
+      return
+    }
+
+    var oldMetrics = bucket.metrics
+    oldMetrics.count += metrics.count
+
+    // iterate through each new metric and merge
+    mapOwn(metrics, function (key, value) {
+      // count is a special case handled above
+      if (key === 'count') return
+
+      var oldMetric = oldMetrics[key]
+      var newMetric = metrics[key]
+
+      // handling the case where newMetric is a single-value first
+      if (newMetric && !newMetric.c) {
+        oldMetrics[key] = updateMetric(newMetric.t, oldMetric)
+      } else { // newMetric is a metric object
+        oldMetrics[key] = mergeMetric(newMetric, oldMetrics[key])
+      }
+    })
+  }
+
+  storeMetric (type, name, params, value) {
+    var bucket = this.getBucket(type, name, params)
+    bucket.stats = updateMetric(value, bucket.stats)
+    return bucket
+  }
+
+  getBucket (type, name, params, customParams) {
+    if (!this.aggregatedData[type]) this.aggregatedData[type] = {}
+    var bucket = this.aggregatedData[type][name]
+    if (!bucket) {
+      bucket = this.aggregatedData[type][name] = { params: params || {} }
+      if (customParams) {
+        bucket.custom = customParams
+      }
+    }
+    return bucket
+  }
+
+  get (type, name) {
+    // if name is passed, get a single bucket
+    if (name) return this.aggregatedData[type] && this.aggregatedData[type][name]
+    // else, get all buckets of that type
+    return this.aggregatedData[type]
+  }
+
+  // Like get, but for many types and it deletes the retrieved content from the aggregatedData
+  take (types) {
+    var results = {}
+    var type = ''
+    var hasData = false
+    for (var i = 0; i < types.length; i++) {
+      type = types[i]
+      results[type] = toArray(this.aggregatedData[type])
+      if (results[type].length) hasData = true
+      delete this.aggregatedData[type]
+    }
+    return hasData ? results : null
+  }
+}
+
+function aggregateMetrics (newMetrics, oldMetrics) {
+  if (!oldMetrics) oldMetrics = { count: 0 }
+  oldMetrics.count += 1
+  mapOwn(newMetrics, function (key, value) {
+    oldMetrics[key] = updateMetric(value, oldMetrics[key])
+  })
+  return oldMetrics
+}
+
+function updateMetric (value, metric) {
+  // when there is no value, then send only count
+  if (value == null) {
+    return updateCounterMetric(metric)
+  }
+
+  // When there is only one data point, the c (count), min, max, and sos (sum of squares) params are superfluous.
+  if (!metric) return { t: value }
+
+  // but on the second data point, we need to calculate the other values before aggregating in new values
+  if (!metric.c) {
+    metric = createMetricObject(metric.t)
+  }
+
+  // at this point, metric is always uncondensed
+  metric.c += 1
+  metric.t += value
+  metric.sos += value * value
+  if (value > metric.max) metric.max = value
+  if (value < metric.min) metric.min = value
+
+  return metric
+}
+
+function updateCounterMetric (metric) {
+  if (!metric) {
+    metric = { c: 1 }
+  } else {
+    metric.c++
+  }
+  return metric
+}
+
+function mergeMetric (newMetric, oldMetric) {
+  if (!oldMetric) return newMetric
+
+  if (!oldMetric.c) {
+    // oldMetric is a single-value
+    oldMetric = createMetricObject(oldMetric.t)
+  }
+
+  oldMetric.min = Math.min(newMetric.min, oldMetric.min)
+  oldMetric.max = Math.max(newMetric.max, oldMetric.max)
+  oldMetric.t += newMetric.t
+  oldMetric.sos += newMetric.sos
+  oldMetric.c += newMetric.c
+
+  return oldMetric
+}
+
+// take a value and create a metric object
+function createMetricObject (value) {
+  return {
+    t: value,
+    min: value,
+    max: value,
+    sos: value * value,
+    c: 1
+  }
+}
+
+function toArray (obj) {
+  if (typeof obj !== 'object') return []
+
+  return mapOwn(obj, getValue)
+}
+
+function getValue (key, value) {
+  return value
+}

package/src/common/browser-version/firefox-version.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable no-useless-escape */
+
+export var ffVersion = 0
+var match = navigator.userAgent.match(/Firefox[\/\s](\d+\.\d+)/)
+if (match) ffVersion = +match[1]

package/src/common/browser-version/ios-version.js

@@ -0,0 +1,10 @@
+export 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-
+export 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+.
+*/

package/src/common/config/config.js

@@ -0,0 +1,12 @@
+import { getInfo, isValid, setInfo } from './state/info'
+import { getConfiguration, getConfigurationValue, setConfiguration } from './state/init'
+import { getLoaderConfig, setLoaderConfig } from './state/loader-config'
+import { originals } from './state/originals'
+import { getRuntime, setRuntime } from './state/runtime'
+
+function isConfigured (agentIdentifier) {
+  return isValid(agentIdentifier)
+}
+
+// This module acts as a hub that bundles the static and dynamic properties used by each agent instance into one single interface
+export { getInfo, setInfo, getConfiguration, getConfigurationValue, setConfiguration, getLoaderConfig, setLoaderConfig, originals, getRuntime, setRuntime, isConfigured }

package/src/common/config/state/configurable.js

@@ -0,0 +1,26 @@
+import { getFrozenAttributes } from '../../../loaders/features/featureDependencies'
+import { warn } from '../../util/console'
+
+export class Configurable {
+  constructor (obj, model) {
+    try {
+      if (!obj || typeof obj !== 'object') return warn('New setting a Configurable requires an object as input')
+      if (!model || typeof model !== 'object') return warn('Setting a Configurable requires a model to set its initial properties')
+      Object.assign(this, model)
+      Object.entries(obj).forEach(([key, value]) => {
+        const frozenAttrs = getFrozenAttributes(key)
+        if (frozenAttrs.length && value && typeof value === 'object') {
+          frozenAttrs.forEach(attr => {
+            if (attr in value) {
+              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) {
+      warn('An error occured while setting a Configurable', err)
+    }
+  }
+}

package/src/common/config/state/info.js

@@ -0,0 +1,49 @@
+import { defaults as nrDefaults, gosNREUMInitializedAgents } from '../../window/nreum'
+import { Configurable } from './configurable'
+
+const model = {
+  // preset defaults
+  beacon: nrDefaults.beacon,
+  errorBeacon: nrDefaults.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 = {}
+
+export function isValid (id) {
+  try {
+    const info = getInfo(id)
+    return (!!info.licenseKey && !!info.errorBeacon && !!info.applicationID)
+  } catch (err) {
+    return false
+  }
+}
+
+export 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]
+}
+
+export function setInfo (id, obj) {
+  if (!id) throw new Error('All info objects require an agent identifier!')
+  _cache[id] = new Configurable(obj, model)
+  gosNREUMInitializedAgents(id, _cache[id], 'info')
+}

package/src/common/config/state/init.js

@@ -0,0 +1,56 @@
+
+import { gosNREUMInitializedAgents } from '../../window/nreum'
+import { Configurable } from './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 = {}
+
+export 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]
+}
+
+export function setConfiguration (id, obj) {
+  if (!id) throw new Error('All configuration objects require an agent identifier!')
+  _cache[id] = new Configurable(obj, model)
+  gosNREUMInitializedAgents(id, _cache[id], 'config')
+}
+
+export 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/src/common/config/state/loader-config.js

@@ -0,0 +1,25 @@
+import { gosNREUMInitializedAgents } from '../../window/nreum'
+import { Configurable } from './configurable'
+
+const model = {
+  accountID: undefined,
+  trustKey: undefined,
+  agentID: undefined,
+  licenseKey: undefined,
+  applicationID: undefined,
+  xpid: undefined
+}
+
+const _cache = {}
+
+export 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]
+}
+
+export function setLoaderConfig (id, obj) {
+  if (!id) throw new Error('All loader-config objects require an agent identifier!')
+  _cache[id] = new Configurable(obj, model)
+  gosNREUMInitializedAgents(id, _cache[id], 'loader_config')
+}

package/src/common/config/state/originals.js

@@ -0,0 +1,3 @@
+import { gosNREUMOriginals } from '../../window/nreum'
+
+export const originals = gosNREUMOriginals().o

package/src/common/config/state/runtime.js

@@ -0,0 +1,45 @@
+import * as userAgent from '../../util/user-agent'
+import { Configurable } from './configurable'
+import { gosNREUMInitializedAgents } from '../../window/nreum'
+import { getCurrentSessionIdOrMakeNew } from '../../window/session-storage'
+import { getConfigurationValue } from '../config'
+import { globalScope } from '../../util/global-scope'
+import { BUILD_ENV, DIST_METHOD, VERSION } from '../../constants/environment-variables'
+
+const model = agentId => { return {
+  buildEnv: BUILD_ENV,
+  bytesSent: {},
+  customTransaction: undefined,
+  disabled: false,
+  distMethod: 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?.performance?.timeOrigin || globalScope?.performance?.timing?.navigationStart || Date.now()),
+  onerror: undefined,
+  origin: '' + globalScope.location,
+  ptid: undefined,
+  releaseIds: {},
+  sessionId: getConfigurationValue(agentId, 'privacy.cookies_enabled') == true
+    ? getCurrentSessionIdOrMakeNew()
+    : null, // if cookies (now session tracking) is turned off or can't get session ID, this is null
+  xhrWrappable: typeof globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
+  userAgent,
+  version: VERSION
+} }
+
+const _cache = {}
+
+export 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]
+}
+
+export function setRuntime (id, obj) {
+  if (!id) throw new Error('All runtime objects require an agent identifier!')
+  _cache[id] = new Configurable(obj, model(id))
+  gosNREUMInitializedAgents(id, _cache[id], 'runtime')
+}

package/src/common/constants/environment-variables.js

@@ -0,0 +1,11 @@
+// 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.
+export const VERSION = typeof process.env.BUILD_VERSION !== 'undefined' && process.env.BUILD_VERSION || ''
+
+// process.env.BUILD_ENV is replaced during webpack -or- npm build with environment vars supplied at build time
+// LOCAL, PROD, DEV, etc
+export const BUILD_ENV = typeof process.env.BUILD_ENV !== 'undefined' && process.env.BUILD_ENV || ''
+
+// process.env.DIST_METHOD is replaced during webpack -or- npm build with environment vars supplied at build time
+// CDN, NPM etc
+export const DIST_METHOD = typeof process.env.DIST_METHOD !== 'undefined' && process.env.DIST_METHOD || ''

package/src/common/context/shared-context.js

@@ -0,0 +1,21 @@
+
+import { warn } from '../util/console'
+
+const model = {
+  agentIdentifier: ''
+}
+
+export class SharedContext {
+  constructor (context) {
+    try {
+      if (typeof context !== 'object') return warn('shared context requires an object as input')
+      this.sharedContext = {}
+      Object.assign(this.sharedContext, model)
+      Object.entries(context).forEach(([key, value]) => {
+        if (Object.keys(model).includes(key)) this.sharedContext[key] = value
+      })
+    } catch (err) {
+      warn('An error occured while setting SharedContext', err)
+    }
+  }
+}

package/src/common/deny-list/deny-list.js

@@ -0,0 +1,116 @@
+/** 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`
+ */
+export 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
+ */
+export 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/src/common/drain/drain.js

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ee } from '../event-emitter/contextual-ee'
+import { mapOwn } from '../util/map-own'
+import { registerHandler as defaultRegister } from '../event-emitter/register-handler'
+import { featurePriority } from '../../loaders/features/features'
+
+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.
+ */
+export 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: 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.
+ */
+export function drain (agentIdentifier = '', featureName = '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(([key, values]) => values.staged)) {
+    items.sort((a, b) => a[1].priority - b[1].priority)
+    items.forEach(([group]) => {
+      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 ? ee.get(agentIdentifier) : ee
+    const handlers = defaultRegister.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)
+      }
+
+      mapOwn(groupHandlers, function (eventType, handlerRegistrationList) {
+        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]
+  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)
+    }
+  })
+}