@newrelic/browser-agent 0.0.9 → 0.1.229

package/dist/cjs/loaders/features/featureDependencies.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFeatureDependencyNames = getFeatureDependencyNames;
+exports.getFrozenAttributes = getFrozenAttributes;
+var _features = require("./features");
+function getFeatureDependencyNames(feature) {
+  switch (feature) {
+    case _features.FEATURE_NAMES.ajax:
+      return [_features.FEATURE_NAMES.jserrors];
+    case _features.FEATURE_NAMES.sessionTrace:
+      return [_features.FEATURE_NAMES.ajax, _features.FEATURE_NAMES.pageViewEvent];
+    case _features.FEATURE_NAMES.pageViewTiming:
+      return [_features.FEATURE_NAMES.pageViewEvent];
+    // this could change if we disconnect window load timings
+    default:
+      return [];
+  }
+}
+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 _features.FEATURE_NAMES.jserrors:
+      return [];
+    default:
+      return ['auto'];
+  }
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.featurePriority = exports.FEATURE_NAMES = void 0;
+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.
+ */
+exports.FEATURE_NAMES = FEATURE_NAMES;
+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
+};
+exports.featurePriority = featurePriority;

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

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MicroAgent = void 0;
+var _enabledFeatures = require("./features/enabled-features");
+var _configure = require("./configure/configure");
+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 _features = require("./features/features");
+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; }
+const nonAutoFeatures = [_features.FEATURE_NAMES.jserrors, _features.FEATURE_NAMES.pageAction];
+const autoFeatures = [_features.FEATURE_NAMES.metrics];
+
+/**
+ * A minimal agent class designed to be loaded multiple times on the same page, each instance narrowly scoped to the
+ * concerns of a particular component, as with the micro-frontend architectural pattern. This class does not
+ * automatically instrument. Instead, each MicroAgent instance may be configured to lazy-load specific
+ * instrumentations at runtime, and to report desired data, events, and errors programatically.
+ */
+class MicroAgent {
+  /**
+   * @param {Object} options - Specifies features and runtime configuration,
+   * @param {string=} agentIdentifier - The optional unique ID of the agent.
+   */
+  constructor(options, agentIdentifier = (0, _uniqueId.generateRandomHexString)(16)) {
+    this.agentIdentifier = agentIdentifier;
+    this.sharedAggregator = new _aggregator.Aggregator({
+      agentIdentifier: this.agentIdentifier
+    });
+    this.features = {};
+    Object.assign(this, (0, _configure.configure)(this.agentIdentifier, {
+      ...options,
+      runtime: {
+        isolatedBacklog: true
+      }
+    }, options.loaderType || 'micro-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() {
+    try {
+      const enabledFeatures = (0, _enabledFeatures.getEnabledFeatures)(this.agentIdentifier);
+      autoFeatures.forEach(f => {
+        if (enabledFeatures[f]) {
+          // TODO - THIS does not work, the instrument switch in lazy loader increases the size of the worker build.  Needs to be revisited
+          Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "lazy-loader" */'../features/utils/lazy-loader'))).then(({
+            lazyLoader
+          }) => {
+            return lazyLoader(f, 'instrument');
+          }).then(({
+            Instrument
+          }) => {
+            this.features[f] = new Instrument(this.agentIdentifier, this.sharedAggregator);
+          }).catch(err => (0, _console.warn)('Something prevented the agent from being downloaded.'));
+        }
+      });
+      nonAutoFeatures.forEach(f => {
+        if (enabledFeatures[f]) {
+          // TODO - THIS does not work, the instrument switch in lazy loader increases the size of the worker build.  Needs to be revisited
+          // Parts of the lazy-loader were removed because webpack was transpiling them into the worker build, errantly inflating the build size.
+          Promise.resolve().then(() => _interopRequireWildcard(require( /* webpackChunkName: "lazy-loader" */'../features/utils/lazy-loader'))).then(({
+            lazyLoader
+          }) => {
+            return lazyLoader(f, 'aggregate');
+          }).then(({
+            Aggregate
+          }) => {
+            this.features[f] = new Aggregate(this.agentIdentifier, this.sharedAggregator);
+          }).catch(err => (0, _console.warn)('Something prevented the agent from being downloaded.'));
+        }
+      });
+      (0, _nreum.gosNREUMInitializedAgents)(this.agentIdentifier, this.features, 'features');
+      return this;
+    } catch (err) {
+      (0, _console.warn)('Failed to initialize instrument classes.', err);
+      return false;
+    }
+  }
+}
+exports.MicroAgent = MicroAgent;

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WorkerAgent = void 0;
+var _agent = require("./agent");
+var _instrument = require("../features/metrics/instrument");
+var _instrument2 = require("../features/jserrors/instrument");
+var _instrument3 = require("../features/ajax/instrument");
+var _instrument4 = require("../features/page_action/instrument");
+/**
+ * A streamlined agent class designed for the service worker context, limited to features relevant in that scope.
+ */
+class WorkerAgent extends _agent.Agent {
+  constructor(args) {
+    super({
+      ...args,
+      features: [_instrument.Instrument, _instrument2.Instrument, _instrument3.Instrument, _instrument4.Instrument],
+      loaderType: 'worker-agent'
+    });
+  }
+}
+exports.WorkerAgent = WorkerAgent;

package/dist/esm/cdn/lite.js

@@ -0,0 +1,12 @@
+/**
+ * @file Creates a "Lite" agent loader bundle composed of the core Agent and a subset of available feature modules.
+ */
+
+import { Agent } from '../loaders/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';
+new Agent({
+  features: [InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentMetrics],
+  loaderType: 'lite'
+});

package/dist/esm/cdn/polyfills/lite.js

@@ -0,0 +1,7 @@
+/**
+ * @file Creates a version of the "Lite" agent loader with [core-js]{@link https://github.com/zloirock/core-js}
+ * polyfills for pre-ES6 browsers and IE 11.
+ */
+
+import '../polyfills.js';
+import '../lite';

package/dist/esm/cdn/polyfills/pro.js

@@ -0,0 +1,7 @@
+/**
+ * @file Creates a version of the "Pro" agent loader with [core-js]{@link https://github.com/zloirock/core-js}
+ * polyfills for pre-ES6 browsers and IE 11.
+ */
+
+import '../polyfills.js';
+import '../pro';

package/dist/esm/cdn/polyfills/spa.js

@@ -0,0 +1,7 @@
+/**
+ * @file Creates a version of the "SPA" agent loader with [core-js]{@link https://github.com/zloirock/core-js}
+ * polyfills for pre-ES6 browsers and IE 11.
+ */
+
+import '../polyfills.js';
+import '../spa';

package/dist/esm/cdn/polyfills.js

@@ -0,0 +1,17 @@
+/**
+ * @file Selectively imports {@link https://github.com/zloirock/core-js core-js}
+ *     polyfills needed for pre-ES6 browsers and IE 11.
+ */
+
+import 'core-js/stable/promise';
+import 'core-js/stable/array/includes';
+import 'core-js/stable/array/from';
+import 'core-js/stable/array/find';
+import 'core-js/stable/array/some';
+import 'core-js/stable/object/assign';
+import 'core-js/stable/object/entries';
+import 'core-js/stable/object/values';
+import 'core-js/stable/map';
+import 'core-js/stable/reflect';
+import 'core-js/stable/set';
+import 'core-js/stable/weak-set';

package/dist/esm/cdn/pro.js

@@ -0,0 +1,17 @@
+/**
+ * @file Creates a "Pro" agent loader bundle composed of the core Agent and all available feature modules except `spa`.
+ * This excludes collection of BrowserInteraction and BrowserTiming events.
+ */
+
+import { Agent } from '../loaders/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 InstrumentPageAction } from '../features/page_action/instrument';
+new Agent({
+  features: [InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentXhr, InstrumentMetrics, InstrumentPageAction, InstrumentErrors],
+  loaderType: 'pro'
+});

package/dist/esm/cdn/spa.js

@@ -0,0 +1,17 @@
+/**
+ * @file Creates a "SPA" agent loader bundle composed of the core agent and all available feature modules.
+ */
+
+import { Agent } from '../loaders/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';
+new Agent({
+  features: [InstrumentXhr, InstrumentPageViewEvent, InstrumentPageViewTiming, InstrumentSessionTrace, InstrumentMetrics, InstrumentPageAction, InstrumentErrors, InstrumentSpa],
+  loaderType: 'spa'
+});

package/dist/esm/cdn/worker.js

@@ -0,0 +1,14 @@
+/**
+ * @file Creates a "Worker" agent loader bundle composed of the core Agent and the subset of feature modules applicable
+ * in a service worker context.
+ */
+
+import { Agent } from '../loaders/agent';
+import { Instrument as InstrumentMetrics } from '../features/metrics/instrument';
+import { Instrument as InstrumentErrors } from '../features/jserrors/instrument';
+import { Instrument as InstrumentXhr } from '../features/ajax/instrument';
+import { Instrument as InstrumentPageAction } from '../features/page_action/instrument';
+new Agent({
+  features: [InstrumentMetrics, InstrumentErrors, InstrumentXhr, InstrumentPageAction],
+  loaderType: 'worker'
+});

package/dist/esm/common/aggregate/aggregator.js

@@ -0,0 +1,161 @@
+/*
+ * 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/dist/esm/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/dist/esm/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/dist/esm/common/config/config.js

@@ -0,0 +1,11 @@
+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/dist/esm/common/config/state/configurable.js

@@ -0,0 +1,25 @@
+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/dist/esm/common/config/state/info.js

@@ -0,0 +1,42 @@
+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/dist/esm/common/config/state/init.js

@@ -0,0 +1,78 @@
+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/dist/esm/common/config/state/loader-config.js

@@ -0,0 +1,21 @@
+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/dist/esm/common/config/state/originals.js

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