@newrelic/browser-agent 0.0.9 → 0.1.229

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

@@ -0,0 +1,41 @@
+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,
+    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/dist/esm/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 "0.1.229" !== 'undefined' && "0.1.229" || '';
+
+// 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 "NPM" !== 'undefined' && "NPM" || '';
+
+// 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 "NPM" !== 'undefined' && "NPM" || '';

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

@@ -0,0 +1,18 @@
+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/dist/esm/common/deny-list/deny-list.js

@@ -0,0 +1,101 @@
+/** 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/dist/esm/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);
+    }
+  });
+}

package/dist/esm/common/event-emitter/contextual-ee.js

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { gosNREUM } from '../window/nreum';
+import { getOrSet } from '../util/get-or-set';
+import { mapOwn } from '../util/map-own';
+import { getRuntime } from '../config/config';
+var ctxId = 'nr@context';
+
+// create global emitter instance that can be shared among bundles
+let nr = gosNREUM();
+var globalInstance;
+if (nr.ee) {
+  globalInstance = nr.ee;
+} else {
+  globalInstance = ee(undefined, 'globalEE');
+  nr.ee = globalInstance;
+}
+export { globalInstance as ee };
+function EventContext() {}
+function ee(old, debugId) {
+  var handlers = {};
+  var bufferGroupMap = {};
+  var emitters = {};
+  // In cases where multiple agents can run on a page, the event backlogs of feature event emitters must be isolated
+  // to prevent event emitter context and buffers from "bubbling up" to other agents operating in the scope.
+  // An example of this is our MicroAgent loader package, which sets this property to true to prevent overlap.
+  var isolatedBacklog = false;
+  try {
+    // We only want to check the runtime configuration for `isolatedBacklog` if the event emitter belongs to a feature.
+    // For feature event emitters, the debugId will be an agentIdentifier with a length of 16. In contrast, some of our
+    // tests do not namespace the event emitter with an agentID and just use the parent (which has no ID).
+    isolatedBacklog = debugId.length !== 16 ? false : getRuntime(debugId).isolatedBacklog;
+  } catch (err) {
+    // Do nothing for now.
+  }
+  var emitter = {
+    on: addEventListener,
+    addEventListener: addEventListener,
+    removeEventListener: removeEventListener,
+    emit: emit,
+    get: getOrCreate,
+    listeners: listeners,
+    context: context,
+    buffer: bufferEventsByGroup,
+    abort,
+    aborted: false,
+    isBuffering: isBuffering,
+    debugId,
+    backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {}
+  };
+  return emitter;
+  function context(contextOrStore) {
+    if (contextOrStore && contextOrStore instanceof EventContext) {
+      return contextOrStore;
+    } else if (contextOrStore) {
+      return getOrSet(contextOrStore, ctxId, getNewContext);
+    } else {
+      return getNewContext();
+    }
+  }
+  function emit(type, args, contextOrStore, force, bubble) {
+    if (bubble !== false) bubble = true;
+    if (globalInstance.aborted && !force) {
+      return;
+    }
+    if (old && bubble) old.emit(type, args, contextOrStore);
+    var ctx = context(contextOrStore);
+    var handlersArray = listeners(type);
+    var len = handlersArray.length;
+
+    // Apply each handler function in the order they were added
+    // to the context with the arguments
+
+    for (var i = 0; i < len; i++) handlersArray[i].apply(ctx, args);
+
+    // Buffer after emitting for consistent ordering
+    var bufferGroup = getBuffer()[bufferGroupMap[type]];
+    if (bufferGroup) {
+      bufferGroup.push([emitter, type, args, ctx]);
+    }
+
+    // Return the context so that the module that emitted can see what was done.
+    return ctx;
+  }
+  function addEventListener(type, fn) {
+    // Retrieve type from handlers, if it doesn't exist assign the default and retrieve it.
+    handlers[type] = listeners(type).concat(fn);
+  }
+  function removeEventListener(type, fn) {
+    var listeners = handlers[type];
+    if (!listeners) return;
+    for (var i = 0; i < listeners.length; i++) {
+      if (listeners[i] === fn) {
+        listeners.splice(i, 1);
+      }
+    }
+  }
+  function listeners(type) {
+    return handlers[type] || [];
+  }
+  function getOrCreate(name) {
+    return emitters[name] = emitters[name] || ee(emitter, name);
+  }
+  function bufferEventsByGroup(types, group) {
+    var eventBuffer = getBuffer();
+
+    // do not buffer events if agent has been aborted
+    if (emitter.aborted) return;
+    mapOwn(types, function (i, type) {
+      group = group || 'feature';
+      bufferGroupMap[type] = group;
+      if (!(group in eventBuffer)) {
+        eventBuffer[group] = [];
+      }
+    });
+  }
+  function isBuffering(type) {
+    var bufferGroup = getBuffer()[bufferGroupMap[type]];
+    return !!bufferGroup;
+  }
+
+  // buffer is associated with a base emitter, since there are two
+  // (global and scoped to the current bundle), it is now part of the emitter
+  function getBuffer() {
+    return emitter.backlog;
+  }
+}
+
+// get context object from store object, or create if does not exist
+export function getOrSetContext(obj) {
+  return getOrSet(obj, ctxId, getNewContext);
+}
+function getNewContext() {
+  return new EventContext();
+}
+function abort() {
+  globalInstance.aborted = true;
+  globalInstance.backlog = {};
+}

package/dist/esm/common/event-emitter/handle.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ee as globalInstance } from './contextual-ee';
+export var handleEE = globalInstance.get('handle');
+export function handle(type, args, ctx, group, ee) {
+  if (ee) {
+    ee.buffer([type], group);
+    ee.emit(type, args, ctx);
+  } else {
+    handleEE.buffer([type], group);
+    handleEE.emit(type, args, ctx);
+  }
+}

package/dist/esm/common/event-emitter/register-handler.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { handleEE } from './handle';
+export { defaultRegister as registerHandler };
+defaultRegister.on = registerWithSpecificEmitter;
+var handlers = defaultRegister.handlers = {};
+export function defaultRegister(type, handler, group, ee) {
+  registerWithSpecificEmitter(ee || handleEE, handlers, type, handler, group);
+}
+function registerWithSpecificEmitter(ee, handlers, type, handler, group) {
+  if (!group) group = 'feature';
+  if (!ee) ee = handleEE;
+  var groupHandlers = handlers[group] = handlers[group] || {};
+  var list = groupHandlers[type] = groupHandlers[type] || [];
+  list.push([ee, handler]);
+}

package/dist/esm/common/event-listener/event-listener-opts.js

@@ -0,0 +1,39 @@
+import { globalScope } from '../util/global-scope';
+
+/*
+ * See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#safely_detecting_option_support
+ */
+let passiveSupported = false;
+let signalSupported = false;
+try {
+  const options = {
+    get passive() {
+      // this function will be called when the browser attempts to access the passive property
+      passiveSupported = true;
+      return false;
+    },
+    get signal() {
+      signalSupported = true;
+      return false;
+    }
+  };
+  globalScope.addEventListener('test', null, options);
+  globalScope.removeEventListener('test', null, options);
+} catch (err) {}
+export function eventListenerOpts(useCapture, abortSignal) {
+  return passiveSupported || signalSupported ? {
+    capture: !!useCapture,
+    passive: passiveSupported,
+    // passive defaults to false
+    signal: abortSignal
+  } : !!useCapture; // mainly just IE11 doesn't support third param options under EventTarget API
+}
+
+/** Do not use this within the worker context. */
+export function windowAddEventListener(event, listener, capture = false) {
+  window.addEventListener(event, listener, eventListenerOpts(capture));
+}
+/** Do not use this within the worker context. */
+export function documentAddEventListener(event, listener, capture = false) {
+  document.addEventListener(event, listener, eventListenerOpts(capture));
+}

package/dist/esm/common/harvest/harvest-scheduler.js

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { submitData } from '../util/submit-data';
+import { SharedContext } from '../context/shared-context';
+import { Harvest, getSubmitMethod } from './harvest';
+import { subscribeToEOL } from '../unload/eol';
+import { getConfigurationValue } from '../config/config';
+
+/**
+ * Periodically invokes harvest calls and handles retries
+ */
+export class HarvestScheduler extends SharedContext {
+  constructor(endpoint, opts, parent) {
+    super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
+    this.endpoint = endpoint;
+    this.opts = opts || {};
+    this.started = false;
+    this.timeoutHandle = null;
+    this.aborted = false; // this controls the per-interval and final harvests for the scheduler (currently per feature specific!)
+
+    this.harvest = new Harvest(this.sharedContext);
+    subscribeToEOL(() => {
+      if (this.aborted) return;
+
+      // If opts.onUnload is defined, these are special actions to execute before attempting to send the final payload.
+      if (this.opts.onUnload) this.opts.onUnload();
+      this.runHarvest({
+        unload: true
+      });
+    }, getConfigurationValue(this.sharedContext.agentIdentifier, 'allow_bfcache')); // TO DO: remove feature flag after rls stable
+  }
+
+  startTimer(interval, initialDelay) {
+    this.interval = interval;
+    this.started = true;
+    this.scheduleHarvest(initialDelay != null ? initialDelay : this.interval);
+  }
+  stopTimer(permanently = false) {
+    this.aborted = permanently; // stopping permanently is same as aborting, but this function also cleans up the setTimeout loop
+    this.started = false;
+    if (this.timeoutHandle) {
+      clearTimeout(this.timeoutHandle);
+    }
+  }
+  scheduleHarvest(delay, opts) {
+    if (this.timeoutHandle) return;
+    var timer = this;
+    if (delay == null) {
+      delay = this.interval;
+    }
+    this.timeoutHandle = setTimeout(() => {
+      timer.timeoutHandle = null;
+      timer.runHarvest(opts);
+    }, delay * 1000);
+  }
+  runHarvest(opts) {
+    if (this.aborted) return;
+    var scheduler = this;
+    if (this.opts.getPayload) {
+      // Ajax & PVT
+      var submitMethod = getSubmitMethod(this.endpoint, opts);
+      if (!submitMethod) return false;
+      var retry = submitMethod.method === submitData.xhr;
+      var payload = this.opts.getPayload({
+        retry: retry
+      });
+      if (payload) {
+        payload = Object.prototype.toString.call(payload) === '[object Array]' ? payload : [payload];
+        for (var i = 0; i < payload.length; i++) {
+          this.harvest.send(this.endpoint, payload[i], opts, submitMethod, onHarvestFinished);
+        }
+      }
+    } else {
+      const runAfterSending = opts?.unload ? undefined : onHarvestFinished; // don't bother running onFinish handler if this is the final harvest
+      this.harvest.sendX(this.endpoint, opts, runAfterSending);
+    }
+    if (this.started) {
+      this.scheduleHarvest();
+    }
+    return;
+    function onHarvestFinished(result) {
+      if (result.blocked) scheduler.onHarvestBlocked(opts, result);else scheduler.onHarvestFinished(opts, result);
+    }
+  }
+  onHarvestFinished(opts, result) {
+    if (this.opts.onFinished) {
+      this.opts.onFinished(result);
+    }
+    if (result.sent && result.retry) {
+      var delay = result.delay || this.opts.retryDelay;
+      // reschedule next harvest if should be delayed longer
+      if (this.started && delay) {
+        clearTimeout(this.timeoutHandle);
+        this.timeoutHandle = null;
+        this.scheduleHarvest(delay, opts);
+      } else if (!this.started && delay) {
+        // if not running on a timer, schedule a single retry
+        this.scheduleHarvest(delay, opts);
+      }
+    }
+  }
+}