@newrelic/browser-agent 0.1.229 → 0.1.230

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 = {}
+}

package/src/common/event-emitter/handle.js

@@ -0,0 +1,17 @@
+/*
+ * 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/src/common/event-emitter/register-handler.js

@@ -0,0 +1,25 @@
+/*
+ * 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/src/common/event-listener/event-listener-opts.js

@@ -0,0 +1,41 @@
+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/src/common/harvest/harvest-scheduler.js

@@ -0,0 +1,112 @@
+/*
+ * 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)
+      }
+    }
+  }
+}

package/src/common/harvest/harvest.js

@@ -0,0 +1,248 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { mapOwn } from '../util/map-own'
+import { obj as encodeObj, param as encodeParam } from '../url/encode'
+import { stringify } from '../util/stringify'
+import { submitData } from '../util/submit-data'
+import { getLocation } from '../url/location'
+import { getInfo, getConfigurationValue, getRuntime, getConfiguration } from '../config/config'
+import { cleanURL } from '../url/clean-url'
+import { now } from '../timing/now'
+import { eventListenerOpts } from '../event-listener/event-listener-opts'
+import { Obfuscator } from '../util/obfuscate'
+import { applyFnToProps } from '../util/traverse'
+import { SharedContext } from '../context/shared-context'
+import { VERSION } from '../constants/environment-variables'
+import { isBrowserScope, isWorkerScope } from '../util/global-scope'
+
+const haveSendBeacon = !!navigator.sendBeacon // only the web window obj has sendBeacon at this time, so 'false' for other envs
+
+export class Harvest extends SharedContext {
+  constructor (parent) {
+    super(parent) // gets any allowed properties from the parent and stores them in `sharedContext`
+
+    this.tooManyRequestsDelay = getConfigurationValue(this.sharedContext.agentIdentifier, 'harvest.tooManyRequestsDelay') || 60
+    this.obfuscator = new Obfuscator(this.sharedContext)
+    this.getScheme = () => (getConfigurationValue(this.sharedContext.agentIdentifier, 'ssl') === false) ? 'http' : 'https'
+
+    this._events = {}
+  }
+
+  /**
+   * Initiate a harvest from multiple sources. An event that corresponds to the endpoint
+   * name is emitted, which gives any listeners the opportunity to provide payload data.
+   *
+   * @param {string} endpoint - The endpoint of the harvest (jserrors, events, resources etc.)
+   *
+   * @param {object} opts
+   * @param {bool} opts.needResponse - Specify whether the caller expects a response data.
+   * @param {bool} opts.unload - Specify whether the call is a final harvest during page unload.
+   */
+  sendX (endpoint, opts, cbFinished) {
+    var submitMethod = getSubmitMethod(endpoint, opts)
+    if (!submitMethod) return false
+    var options = {
+      retry: submitMethod.method === submitData.xhr
+    }
+    return this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend(endpoint, this.createPayload(endpoint, options), opts, submitMethod, cbFinished) : this._send(endpoint, this.createPayload(endpoint, options), opts, submitMethod, cbFinished)
+  }
+
+  /**
+ * Initiate a harvest call.
+ *
+ * @param {string} endpoint - The endpoint of the harvest (jserrors, events, resources etc.)
+ * @param {object} nr - The loader singleton.
+ *
+ * @param {object} singlePayload - Object representing payload.
+ * @param {object} singlePayload.qs - Map of values that should be sent as part of the request query string.
+ * @param {string} singlePayload.body - String that should be sent as the body of the request.
+ * @param {string} singlePayload.body.e - Special case of body used for browser interactions.
+ *
+ * @param {object} opts
+ * @param {bool} opts.needResponse - Specify whether the caller expects a response data.
+ * @param {bool} opts.unload - Specify whether the call is a final harvest during page unload.
+ */
+  send (endpoint, singlePayload, opts, submitMethod, cbFinished) {
+    var makeBody = createAccumulator()
+    var makeQueryString = createAccumulator()
+    if (singlePayload.body) mapOwn(singlePayload.body, makeBody)
+    if (singlePayload.qs) mapOwn(singlePayload.qs, makeQueryString)
+
+    var payload = { body: makeBody(), qs: makeQueryString() }
+    var caller = this.obfuscator.shouldObfuscate() ? (...args) => this.obfuscateAndSend(...args) : (...args) => this._send(...args)
+
+    return caller(endpoint, payload, opts, submitMethod, cbFinished)
+  }
+
+  obfuscateAndSend (endpoint, payload, opts, submitMethod, cbFinished) {
+    applyFnToProps(payload, (...args) => this.obfuscator.obfuscateString(...args), 'string', ['e'])
+    return this._send(endpoint, payload, opts, submitMethod, cbFinished)
+  }
+
+  _send (endpoint, payload, opts, submitMethod, cbFinished) {
+    var info = getInfo(this.sharedContext.agentIdentifier)
+    if (!info.errorBeacon) return false
+
+    var agentRuntime = getRuntime(this.sharedContext.agentIdentifier)
+
+    if (!payload.body) { // no payload body? nothing to send, just run onfinish stuff and return
+      if (cbFinished) {
+        cbFinished({ sent: false })
+      }
+      return false
+    }
+
+    if (!opts) opts = {}
+
+    var url = this.getScheme() + '://' + info.errorBeacon + '/' + endpoint + '/1/' + info.licenseKey + this.baseQueryString()
+    if (payload.qs) url += encodeObj(payload.qs, agentRuntime.maxBytes)
+
+    if (!submitMethod) {
+      submitMethod = getSubmitMethod(endpoint, opts)
+    }
+    var method = submitMethod.method
+    var useBody = submitMethod.useBody
+
+    var body
+    var fullUrl = url
+    if (useBody && endpoint === 'events') {
+      body = payload.body.e
+    } else if (useBody) {
+      body = stringify(payload.body)
+    } else {
+      fullUrl = url + encodeObj(payload.body, agentRuntime.maxBytes)
+    }
+
+    // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
+    agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0
+
+    /* Since workers don't support sendBeacon right now, or Image(), they can only use XHR method.
+        Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
+        we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon. */
+    var result = method(fullUrl, body, opts.unload && isWorkerScope)
+
+    if (cbFinished && method === submitData.xhr) {
+      var xhr = result
+      xhr.addEventListener('load', function () {
+        var result = { sent: true }
+        if (this.status === 429) {
+          result.retry = true
+          result.delay = this.tooManyRequestsDelay
+        } else if (this.status === 408 || this.status === 500 || this.status === 503) {
+          result.retry = true
+        }
+
+        if (opts.needResponse) {
+          result.responseText = this.responseText
+        }
+        cbFinished(result)
+      }, eventListenerOpts(false))
+    }
+
+    // if beacon request failed, retry with an alternative method -- will not happen for workers
+    if (!result && method === submitData.beacon) {
+      method = submitData.img
+      result = method(url + encodeObj(payload.body, agentRuntime.maxBytes))
+    }
+
+    return result
+  }
+
+  // The stuff that gets sent every time.
+  baseQueryString () {
+    var runtime = getRuntime(this.sharedContext.agentIdentifier)
+    var info = getInfo(this.sharedContext.agentIdentifier)
+
+    var location = cleanURL(getLocation())
+    var ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location
+
+    return ([
+      '?a=' + info.applicationID,
+      encodeParam('sa', (info.sa ? '' + info.sa : '')),
+      encodeParam('v', VERSION),
+      transactionNameParam(info),
+      encodeParam('ct', runtime.customTransaction),
+      '&rst=' + now(),
+      '&ck=0', // ck param DEPRECATED - still expected by backend
+      '&s=' + (runtime.sessionId || '0'), // the 0 id encaps all untrackable and default traffic
+      encodeParam('ref', ref),
+      encodeParam('ptid', (runtime.ptid ? '' + runtime.ptid : ''))
+    ].join(''))
+  }
+
+  createPayload (type, options) {
+    var makeBody = createAccumulator()
+    var makeQueryString = createAccumulator()
+    var listeners = (this._events[type] && this._events[type] || [])
+
+    for (var i = 0; i < listeners.length; i++) {
+      var singlePayload = listeners[i](options)
+      if (!singlePayload) continue
+      if (singlePayload.body) mapOwn(singlePayload.body, makeBody)
+      if (singlePayload.qs) mapOwn(singlePayload.qs, makeQueryString)
+    }
+    return { body: makeBody(), qs: makeQueryString() }
+  }
+
+  on (type, listener) {
+    var listeners = (this._events[type] || (this._events[type] = []))
+    listeners.push(listener)
+  }
+
+  resetListeners () {
+    mapOwn(this._events, (key) => {
+      this._events[key] = []
+    })
+  }
+}
+
+function or (a, b) { return a || b }
+
+export function getSubmitMethod (endpoint, opts) {
+  opts = opts || {}
+  var method
+  var useBody
+
+  if (opts.needResponse) { // currently: only STN needs a response
+    useBody = true
+    method = submitData.xhr
+  } else if (opts.unload && isBrowserScope) { // all the features' final harvest; neither methods work outside window context
+    useBody = haveSendBeacon
+    method = haveSendBeacon ? submitData.beacon : submitData.img // really only IE doesn't have Beacon API for web browsers
+  } else {
+    // `submitData.beacon` was removed, there is an upper limit to the
+    // number of data allowed before it starts failing, so we save it only for page unloading
+    useBody = true
+    method = submitData.xhr
+  }
+
+  return {
+    method: method,
+    useBody: useBody
+  }
+}
+
+// Constructs the transaction name param for the beacon URL.
+// Prefers the obfuscated transaction name over the plain text.
+// Falls back to making up a name.
+function transactionNameParam (info) {
+  if (info.transactionName) return encodeParam('to', info.transactionName)
+  return encodeParam('t', info.tNamePlain || 'Unnamed Transaction')
+}
+
+// returns a function that can be called to accumulate values to a single object
+// when the function is called without parameters, then the accumulator is returned
+function createAccumulator () {
+  var accumulator = {}
+  var hasData = false
+  return function (key, val) {
+    if (val && val.length) {
+      accumulator[key] = val
+      hasData = true
+    }
+    if (hasData) return accumulator
+  }
+}

package/src/common/ids/id.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Start assigning ids at 1 so 0 can always be used for WindowOrWorkerGlobalScope, without
+// actually setting it (which would create a global variable).
+import { getOrSet } from '../util/get-or-set'
+import { globalScope } from '../util/global-scope'
+
+var index = 1
+var prop = 'nr@id'
+
+// Always returns id of obj, may tag obj with an id in the process.
+export function id (obj) {
+  var type = typeof obj
+  // We can only tag objects, functions, and arrays with ids.
+  // For all primitive values we instead return -1.
+  if (!obj || !(type === 'object' || type === 'function')) return -1
+  if (obj === globalScope) return 0
+
+  return getOrSet(obj, prop, function () { return index++ })
+}