@newrelic/browser-agent 0.1.229 → 0.1.230

package/src/features/ajax/instrument/index.js

@@ -0,0 +1,380 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { originals, getLoaderConfig, getRuntime } from '../../../common/config/config'
+import { handle } from '../../../common/event-emitter/handle'
+import { id } from '../../../common/ids/id'
+import { ffVersion } from '../../../common/browser-version/firefox-version'
+import { dataSize } from '../../../common/util/data-size'
+import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
+import { now } from '../../../common/timing/now'
+import { wrapFetch, wrapXhr } from '../../../common/wrap'
+import { parseUrl } from '../../../common/url/parse-url'
+import { DT } from './distributed-tracing'
+import { responseSizeFromXhr } from './response-size'
+import { InstrumentBase } from '../../utils/instrument-base'
+import { FEATURE_NAME } from '../constants'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
+import { globalScope } from '../../../common/util/global-scope'
+
+var handlers = ['load', 'error', 'abort', 'timeout']
+var handlersLen = handlers.length
+
+var origRequest = originals.REQ
+var origXHR = globalScope.XMLHttpRequest
+
+export class Instrument extends InstrumentBase {
+  static featureName = FEATURE_NAME
+  constructor (agentIdentifier, aggregator, auto = true) {
+    super(agentIdentifier, aggregator, FEATURE_NAME, auto)
+
+    // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
+    if (!getRuntime(agentIdentifier).xhrWrappable) return
+
+    this.dt = new DT(agentIdentifier)
+
+    this.handler = (type, args, ctx, group) => handle(type, args, ctx, group, this.ee)
+    wrapFetch(this.ee)
+    wrapXhr(this.ee)
+    subscribeToEvents(agentIdentifier, this.ee, this.handler, this.dt)
+
+    this.importAggregator()
+  }
+}
+
+function subscribeToEvents (agentIdentifier, ee, handler, dt) {
+  ee.on('new-xhr', onNewXhr)
+  ee.on('open-xhr-start', onOpenXhrStart)
+  ee.on('open-xhr-end', onOpenXhrEnd)
+  ee.on('send-xhr-start', onSendXhrStart)
+  ee.on('xhr-cb-time', onXhrCbTime)
+  ee.on('xhr-load-added', onXhrLoadAdded)
+  ee.on('xhr-load-removed', onXhrLoadRemoved)
+  ee.on('xhr-resolved', onXhrResolved)
+  ee.on('addEventListener-end', onAddEventListenerEnd)
+  ee.on('removeEventListener-end', onRemoveEventListenerEnd)
+  ee.on('fn-end', onFnEnd)
+  ee.on('fetch-before-start', onFetchBeforeStart)
+  ee.on('fetch-start', onFetchStart)
+  ee.on('fn-start', onFnStart)
+  ee.on('fetch-done', onFetchDone)
+
+  // Setup the context for each new xhr object
+  function onNewXhr (xhr) {
+    var ctx = this
+    ctx.totalCbs = 0
+    ctx.called = 0
+    ctx.cbTime = 0
+    ctx.end = end
+    ctx.ended = false
+    ctx.xhrGuids = {}
+    ctx.lastSize = null
+    ctx.loadCaptureCalled = false
+    ctx.params = this.params || {}
+    ctx.metrics = this.metrics || {}
+
+    xhr.addEventListener('load', function (event) {
+      captureXhrData(ctx, xhr)
+    }, eventListenerOpts(false))
+
+    // In Firefox (v34+), XHR ProgressEvents report pre-content-decoding sizes via
+    // their 'loaded' property, rather than post-decoding sizes. We want
+    // post-decoding sizes for consistency with browsers where that's all we have.
+    // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1227674
+    //
+    // So we don't use ProgressEvents to measure XHR sizes for FF.
+    if (ffVersion) return
+
+    xhr.addEventListener('progress', function (event) {
+      ctx.lastSize = event.loaded
+    }, eventListenerOpts(false))
+  }
+
+  function onOpenXhrStart (args) {
+    this.params = { method: args[0] }
+    addUrl(this, args[1])
+    this.metrics = {}
+  }
+
+  function onOpenXhrEnd (args, xhr) {
+    var loader_config = getLoaderConfig(agentIdentifier)
+    if ('xpid' in loader_config && this.sameOrigin) {
+      xhr.setRequestHeader('X-NewRelic-ID', loader_config.xpid)
+    }
+
+    var payload = dt.generateTracePayload(this.parsedOrigin)
+    if (payload) {
+      var added = false
+      if (payload.newrelicHeader) {
+        xhr.setRequestHeader('newrelic', payload.newrelicHeader)
+        added = true
+      }
+      if (payload.traceContextParentHeader) {
+        xhr.setRequestHeader('traceparent', payload.traceContextParentHeader)
+        if (payload.traceContextStateHeader) {
+          xhr.setRequestHeader('tracestate', payload.traceContextStateHeader)
+        }
+        added = true
+      }
+      if (added) {
+        this.dt = payload
+      }
+    }
+  }
+
+  function onSendXhrStart (args, xhr) {
+    var metrics = this.metrics
+    var data = args[0]
+    var context = this
+
+    if (metrics && data) {
+      var size = dataSize(data)
+      if (size) metrics.txSize = size
+    }
+
+    this.startTime = now()
+
+    this.listener = function (evt) {
+      try {
+        if (evt.type === 'abort' && !(context.loadCaptureCalled)) {
+          context.params.aborted = true
+        }
+        if (evt.type !== 'load' || (context.called === context.totalCbs) && (context.onloadCalled || typeof (xhr.onload) !== 'function') && typeof context.end === 'function') context.end(xhr)
+      } catch (e) {
+        try {
+          ee.emit('internal-error', [e])
+        } catch (err) {
+          // do nothing
+        }
+      }
+    }
+
+    for (var i = 0; i < handlersLen; i++) {
+      xhr.addEventListener(handlers[i], this.listener, eventListenerOpts(false))
+    }
+  }
+
+  function onXhrCbTime (time, onload, xhr) {
+    this.cbTime += time
+    if (onload) this.onloadCalled = true
+    else this.called += 1
+    if ((this.called === this.totalCbs) && (this.onloadCalled || typeof (xhr.onload) !== 'function') && typeof this.end === 'function') this.end(xhr)
+  }
+
+  function onXhrLoadAdded (cb, useCapture) {
+    // Ignore if the same arguments are passed to addEventListener twice
+    var idString = '' + id(cb) + !!useCapture
+    if (!this.xhrGuids || this.xhrGuids[idString]) return
+    this.xhrGuids[idString] = true
+
+    this.totalCbs += 1
+  }
+
+  function onXhrLoadRemoved (cb, useCapture) {
+    // Ignore if event listener didn't exist for this xhr object
+    var idString = '' + id(cb) + !!useCapture
+    if (!this.xhrGuids || !this.xhrGuids[idString]) return
+    delete this.xhrGuids[idString]
+
+    this.totalCbs -= 1
+  }
+
+  function onXhrResolved () {
+    this.endTime = now()
+  }
+
+  // Listen for load listeners to be added to xhr objects
+  function onAddEventListenerEnd (args, xhr) {
+    if (xhr instanceof origXHR && args[0] === 'load') ee.emit('xhr-load-added', [args[1], args[2]], xhr)
+  }
+
+  function onRemoveEventListenerEnd (args, xhr) {
+    if (xhr instanceof origXHR && args[0] === 'load') ee.emit('xhr-load-removed', [args[1], args[2]], xhr)
+  }
+
+  // Listen for those load listeners to be called.
+  function onFnStart (args, xhr, methodName) {
+    if (xhr instanceof origXHR) {
+      if (methodName === 'onload') this.onload = true
+      if ((args[0] && args[0].type) === 'load' || this.onload) this.xhrCbStart = now()
+    }
+  }
+
+  function onFnEnd (args, xhr) {
+    if (this.xhrCbStart) ee.emit('xhr-cb-time', [now() - this.xhrCbStart, this.onload, xhr], xhr)
+  }
+
+  // this event only handles DT
+  function onFetchBeforeStart (args) {
+    var opts = args[1] || {}
+    var url
+    // argument is USVString
+    if (typeof args[0] === 'string') {
+      url = args[0]
+      // argument is Request object
+    } else if (args[0] && args[0].url) {
+      url = args[0].url
+      // argument is URL object
+    } else if (globalScope?.URL && args[0] && args[0] instanceof URL) {
+      url = args[0].href
+    }
+
+    if (url) {
+      this.parsedOrigin = parseUrl(url)
+      this.sameOrigin = this.parsedOrigin.sameOrigin
+    }
+
+    var payload = dt.generateTracePayload(this.parsedOrigin)
+    if (!payload || (!payload.newrelicHeader && !payload.traceContextParentHeader)) {
+      return
+    }
+
+    if (typeof args[0] === 'string' || (globalScope?.URL && args[0] && args[0] instanceof URL)) {
+      var clone = {}
+
+      for (var key in opts) {
+        clone[key] = opts[key]
+      }
+
+      clone.headers = new Headers(opts.headers || {})
+      if (addHeaders(clone.headers, payload)) {
+        this.dt = payload
+      }
+
+      if (args.length > 1) {
+        args[1] = clone
+      } else {
+        args.push(clone)
+      }
+    } else if (args[0] && args[0].headers) {
+      if (addHeaders(args[0].headers, payload)) {
+        this.dt = payload
+      }
+    }
+
+    function addHeaders (headersObj, payload) {
+      var added = false
+      if (payload.newrelicHeader) {
+        headersObj.set('newrelic', payload.newrelicHeader)
+        added = true
+      }
+      if (payload.traceContextParentHeader) {
+        headersObj.set('traceparent', payload.traceContextParentHeader)
+        if (payload.traceContextStateHeader) {
+          headersObj.set('tracestate', payload.traceContextStateHeader)
+        }
+        added = true
+      }
+      return added
+    }
+  }
+
+  function onFetchStart (fetchArguments, dtPayload) {
+    this.params = {}
+    this.metrics = {}
+    this.startTime = now()
+    this.dt = dtPayload
+
+    if (fetchArguments.length >= 1) this.target = fetchArguments[0]
+    if (fetchArguments.length >= 2) this.opts = fetchArguments[1]
+
+    var opts = this.opts || {}
+    var target = this.target
+
+    var url
+    if (typeof target === 'string') {
+      url = target
+    } else if (typeof target === 'object' && target instanceof origRequest) {
+      url = target.url
+    } else if (globalScope?.URL && typeof target === 'object' && target instanceof URL) {
+      url = target.href
+    }
+    addUrl(this, url)
+
+    var method = ('' + ((target && target instanceof origRequest && target.method) ||
+      opts.method || 'GET')).toUpperCase()
+    this.params.method = method
+
+    this.txSize = dataSize(opts.body) || 0
+  }
+
+  // we capture failed call as status 0, the actual error is ignored
+  // eslint-disable-next-line handle-callback-err
+  function onFetchDone (err, res) {
+    this.endTime = now()
+    if (!this.params) {
+      this.params = {}
+    }
+    this.params.status = res ? res.status : 0
+
+    // convert rxSize to a number
+    var responseSize
+    if (typeof this.rxSize === 'string' && this.rxSize.length > 0) {
+      responseSize = +this.rxSize
+    }
+
+    var metrics = {
+      txSize: this.txSize,
+      rxSize: responseSize,
+      duration: now() - this.startTime
+    }
+
+    handler('xhr', [this.params, metrics, this.startTime, this.endTime, 'fetch'], this, FEATURE_NAMES.ajax)
+  }
+
+  // Create report for XHR request that has finished
+  function end (xhr) {
+    var params = this.params
+    var metrics = this.metrics
+
+    if (this.ended) return
+    this.ended = true
+
+    for (var i = 0; i < handlersLen; i++) {
+      xhr.removeEventListener(handlers[i], this.listener, false)
+    }
+
+    if (params.aborted) return
+    metrics.duration = now() - this.startTime
+    if (!this.loadCaptureCalled && xhr.readyState === 4) {
+      captureXhrData(this, xhr)
+    } else if (params.status == null) {
+      params.status = 0
+    }
+
+    // Always send cbTime, even if no noticeable time was taken.
+    metrics.cbTime = this.cbTime
+
+    handler('xhr', [params, metrics, this.startTime, this.endTime, 'xhr'], this, FEATURE_NAMES.ajax)
+  }
+
+  function addUrl (ctx, url) {
+    var parsed = parseUrl(url)
+    var params = ctx.params
+
+    params.hostname = parsed.hostname
+    params.port = parsed.port
+    params.protocol = parsed.protocol
+    params.host = parsed.hostname + ':' + parsed.port
+    params.pathname = parsed.pathname
+    ctx.parsedOrigin = parsed
+    ctx.sameOrigin = parsed.sameOrigin
+  }
+
+  function captureXhrData (ctx, xhr) {
+    ctx.params.status = xhr.status
+
+    var size = responseSizeFromXhr(xhr, ctx.lastSize)
+    if (size) ctx.metrics.rxSize = size
+
+    if (ctx.sameOrigin) {
+      var header = xhr.getResponseHeader('X-NewRelic-App-Data')
+      if (header) {
+        ctx.params.cat = header.split(', ').pop()
+      }
+    }
+
+    ctx.loadCaptureCalled = true
+  }
+}

package/src/features/ajax/instrument/response-size.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { dataSize } from '../../../common/util/data-size'
+
+export function responseSizeFromXhr (xhr, lastSize) {
+  var type = xhr.responseType
+  if (type === 'json' && lastSize !== null) return lastSize
+  // Caution! Chrome throws an error if you try to access xhr.responseText for binary data
+  if (type === 'arraybuffer' || type === 'blob' || type === 'json') {
+    return dataSize(xhr.response)
+  } else if (type === 'text' || type === '' || type === undefined) { // empty string type defaults to 'text'
+    return dataSize(xhr.responseText)
+  } else { // e.g. ms-stream and document (we do not currently determine the size of Document objects)
+    return undefined
+  }
+}

package/src/features/jserrors/aggregate/canonical-function-name.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var canonicalFunctionNameRe = /([a-z0-9]+)$/i
+export function canonicalFunctionName (orig) {
+  if (!orig) return
+
+  var match = orig.match(canonicalFunctionNameRe)
+  if (match) return match[1]
+
+  return
+}

package/src/features/jserrors/aggregate/canonical-function-name.test.js

@@ -0,0 +1,13 @@
+import { canonicalFunctionName } from './canonical-function-name'
+
+test.each([
+  { input: null, expected: undefined, title: 'Return undefined if no function name' },
+  { input: 'test', expected: 'test', title: 'Simple function name' },
+  { input: 'scope1/scope2/func', expected: 'func', title: 'Remove Firefox scopes' },
+  { input: 'scope1.func', expected: 'func', title: 'Remove Chrome scopes' },
+  { input: '<anonymous>', expected: undefined, title: 'Return undefined ending is non-alphanumeric' }
+])('$title', ({ input, expected }) => {
+  const result = canonicalFunctionName(input)
+
+  expect(result).toEqual(expected)
+})

package/src/features/jserrors/aggregate/compute-stack-trace.js

@@ -0,0 +1,231 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable no-useless-escape */
+
+// computeStackTrace: cross-browser stack traces in JavaScript
+//
+// Syntax:
+//   s = computeStackTrace(exception) // consider using TraceKit.report instead
+// Returns:
+//   s.name              - exception name
+//   s.message           - exception message
+//   s.stack[i].url      - JavaScript or HTML file URL
+//   s.stack[i].func     - function name, or empty for anonymous functions
+//   s.stack[i].line     - line number, if known
+//   s.stack[i].column   - column number, if known
+//   s.stack[i].context  - an array of source code lines; the middle element corresponds to the correct line#
+//   s.mode              - 'stack', 'stacktrace', 'multiline', 'callers', 'onerror', or 'failed' -- method used to collect the stack trace
+//
+// Supports:
+//   - Firefox:  full stack trace with line numbers and unreliable column
+//               number on top frame
+//   - Chrome:   full stack trace with line and column numbers
+//   - Safari:   line and column number for the topmost stacktrace element
+//               only
+//   - IE:       no line numbers whatsoever
+
+// Contents of Exception in various browsers.
+//
+// SAFARI:
+// ex.message = Can't find variable: qq
+// ex.line = 59
+// ex.sourceId = 580238192
+// ex.sourceURL = http://...
+// ex.expressionBeginOffset = 96
+// ex.expressionCaretOffset = 98
+// ex.expressionEndOffset = 98
+// ex.name = ReferenceError
+//
+// FIREFOX:
+// ex.message = qq is not defined
+// ex.fileName = http://...
+// ex.lineNumber = 59
+// ex.stack = ...stack trace... (see the example below)
+// ex.name = ReferenceError
+//
+// CHROME:
+// ex.message = qq is not defined
+// ex.name = ReferenceError
+// ex.type = not_defined
+// ex.arguments = ['aa']
+// ex.stack = ...stack trace...
+//
+// INTERNET EXPLORER:
+// ex.message = ...
+// ex.name = ReferenceError
+import { formatStackTrace } from './format-stack-trace'
+
+var debug = false
+
+var classNameRegex = /function (.+?)\s*\(/
+var chrome = /^\s*at (?:((?:\[object object\])?(?:[^(]*\([^)]*\))*[^()]*(?: \[as \S+\])?) )?\(?((?:file|http|https|chrome-extension):.*?)?:(\d+)(?::(\d+))?\)?\s*$/i
+var gecko = /^\s*(?:(\S*|global code)(?:\(.*?\))?@)?((?:file|http|https|chrome|safari-extension).*?):(\d+)(?::(\d+))?\s*$/i
+var chrome_eval = /^\s*at .+ \(eval at \S+ \((?:(?:file|http|https):[^)]+)?\)(?:, [^:]*:\d+:\d+)?\)$/i
+var ie_eval = /^\s*at Function code \(Function code:\d+:\d+\)\s*/i
+
+export function computeStackTrace (ex) {
+  var stack = null
+
+  try {
+    stack = computeStackTraceFromStackProp(ex)
+    if (stack) {
+      return stack
+    }
+  } catch (e) {
+    if (debug) {
+      throw e
+    }
+  }
+
+  try {
+    stack = computeStackTraceBySourceAndLine(ex)
+    if (stack) {
+      return stack
+    }
+  } catch (e) {
+    if (debug) {
+      throw e
+    }
+  }
+
+  try {
+    stack = computeStackTraceWithMessageOnly(ex)
+    if (stack) {
+      return stack
+    }
+  } catch (e) {
+    if (debug) {
+      throw e
+    }
+  }
+
+  return {
+    mode: 'failed',
+    stackString: '',
+    frames: []
+  }
+}
+
+/**
+ * Computes stack trace information from the stack property.
+ * Chrome and Gecko use this property.
+ * @param {Error} ex
+ * @return {?Object.<string, *>} Stack trace information.
+ */
+function computeStackTraceFromStackProp (ex) {
+  if (!ex.stack) {
+    return null
+  }
+
+  var errorInfo = ex.stack.split('\n').reduce(
+    parseStackProp,
+    { frames: [], stackLines: [], wrapperSeen: false }
+  )
+
+  if (!errorInfo.frames.length) return null
+
+  return {
+    mode: 'stack',
+    name: ex.name || getClassName(ex),
+    message: ex.message,
+    stackString: formatStackTrace(errorInfo.stackLines),
+    frames: errorInfo.frames
+  }
+}
+
+function parseStackProp (info, line) {
+  var element = getElement(line)
+
+  if (!element) {
+    info.stackLines.push(line)
+    return info
+  }
+
+  if (isWrapper(element.func)) info.wrapperSeen = true
+  else info.stackLines.push(line)
+
+  if (!info.wrapperSeen) info.frames.push(element)
+  return info
+}
+
+function getElement (line) {
+  var parts = line.match(gecko)
+  if (!parts) parts = line.match(chrome)
+
+  if (parts) {
+    return ({
+      url: parts[2],
+      func: (parts[1] !== 'Anonymous function' && parts[1] !== 'global code' && parts[1]) || null,
+      line: +parts[3],
+      column: parts[4] ? +parts[4] : null
+    })
+  }
+
+  if (line.match(chrome_eval) || line.match(ie_eval) || line === 'anonymous') {
+    return { func: 'evaluated code' }
+  }
+}
+
+function computeStackTraceBySourceAndLine (ex) {
+  if (!('line' in ex)) return null
+
+  var className = ex.name || getClassName(ex)
+
+  // Safari does not provide a URL for errors in eval'd code
+  if (!ex.sourceURL) {
+    return ({
+      mode: 'sourceline',
+      name: className,
+      message: ex.message,
+      stackString: getClassName(ex) + ': ' + ex.message + '\n    in evaluated code',
+      frames: [{
+        func: 'evaluated code'
+      }]
+    })
+  }
+
+  var stackString = className + ': ' + ex.message + '\n    at ' + ex.sourceURL
+  if (ex.line) {
+    stackString += ':' + ex.line
+    if (ex.column) {
+      stackString += ':' + ex.column
+    }
+  }
+
+  return ({
+    mode: 'sourceline',
+    name: className,
+    message: ex.message,
+    stackString: stackString,
+    frames: [{
+      url: ex.sourceURL,
+      line: ex.line,
+      column: ex.column
+    }]
+  })
+}
+
+function computeStackTraceWithMessageOnly (ex) {
+  var className = ex.name || getClassName(ex)
+  if (!className) return null
+
+  return ({
+    mode: 'nameonly',
+    name: className,
+    message: ex.message,
+    stackString: className + ': ' + ex.message,
+    frames: []
+  })
+}
+
+function getClassName (obj) {
+  var results = classNameRegex.exec(String(obj.constructor))
+  return (results && results.length > 1) ? results[1] : 'unknown'
+}
+
+function isWrapper (functionName) {
+  return (functionName && functionName.indexOf('nrWrapper') >= 0)
+}