@newrelic/browser-agent 0.1.229 → 0.1.231

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,47 @@
+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/env'
+
+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/env.cdn.js

@@ -0,0 +1,20 @@
+/**
+ * @file This file exposes CDN build environment variables. These variables will
+ * be overridden with babel.
+ */
+
+/**
+ * Exposes the version of the agent
+ */
+export const VERSION = process.env.BUILD_VERSION
+
+/**
+ * Exposes the build type of the agent
+ * Valid values are LOCAL, PROD, DEV
+ */
+export const BUILD_ENV = process.env.BUILD_ENV
+
+/**
+ * Exposes the distribution method of the agent
+ */
+export const DIST_METHOD = 'CDN'

package/src/common/constants/env.js

@@ -0,0 +1,23 @@
+/**
+ * @file This file exposes build time environment variables that will be included in the
+ * build output of the agent. This file specifically contains the normal environment variables
+ * for the NPM agent build and will be overridden by webpack/babel during the build based on the
+ * type of build being performed.
+ */
+
+import pkgJSON from '../../../package.json'
+
+/**
+ * Exposes the version of the agent
+ */
+export const VERSION = pkgJSON.version
+
+/**
+ * Exposes the build type of the agent
+ */
+export const BUILD_ENV = 'NPM'
+
+/**
+ * Exposes the distribution method of the agent
+ */
+export const DIST_METHOD = 'NPM'

package/src/common/constants/env.npm.js

@@ -0,0 +1,21 @@
+/**
+ * @file This file exposes NPM build environment variables. These variables will
+ * be overridden with babel.
+ */
+
+/**
+ * Exposes the version of the agent
+ */
+export const VERSION = process.env.BUILD_VERSION
+
+/**
+ * Exposes the build type of the agent
+ * Valid values are LOCAL, PROD, DEV
+ */
+export const BUILD_ENV = 'NPM'
+
+/**
+ * Exposes the distribution method of the agent
+ * Valid valuse are CDN, NPM
+ */
+export const DIST_METHOD = 'NPM'

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)
+    }
+  })
+}

package/src/common/event-emitter/contextual-ee.js

@@ -0,0 +1,159 @@
+/*
+ * 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 = {}
+}