@newrelic/browser-agent 0.0.9 → 0.1.230

package/src/features/utils/instrument-base.js

@@ -0,0 +1,68 @@
+/**
+ * @file Defines `InstrumentBase` to be used as the super of the Instrument classes implemented by each feature.
+ * Inherits and executes the `checkConfiguration` method from [FeatureBase]{@link ./feature-base}, which also
+ * exposes the `blocked` property.
+ */
+
+import { registerDrain } from '../../common/drain/drain'
+import { FeatureBase } from './feature-base'
+import { onWindowLoad } from '../../common/window/load'
+import { isWorkerScope } from '../../common/util/global-scope'
+import { warn } from '../../common/util/console'
+
+/**
+ * Base class for instrumenting a feature.
+ * @extends FeatureBase
+ */
+export class InstrumentBase extends 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) 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 import(/* webpackChunkName: "lazy-loader" */ './lazy-loader')
+        const { Aggregate } = await lazyLoader(this.featureName, 'aggregate')
+        new Aggregate(this.agentIdentifier, this.aggregator)
+      } catch (e) {
+        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 (isWorkerScope) importLater()
+    else onWindowLoad(() => importLater(), true)
+  }
+}

package/src/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/src/index.js

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

package/src/loaders/agent.js

@@ -0,0 +1,80 @@
+// 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/src/loaders/api/api.js

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

package/src/loaders/api/apiAsync.js

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

package/src/loaders/browser-agent.js

@@ -0,0 +1,33 @@
+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/src/loaders/configure/configure.js

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

package/src/loaders/features/enabled-features.js

@@ -0,0 +1,16 @@
+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/src/loaders/features/featureDependencies.js

@@ -0,0 +1,26 @@
+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/src/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
+}