@newrelic/browser-agent 0.0.9 → 0.1.230

package/dist/esm/features/ajax/instrument/index.js

@@ -0,0 +1,331 @@
+/*
+ * 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) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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/dist/esm/features/ajax/instrument/response-size.js

@@ -0,0 +1,19 @@
+/*
+ * 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/dist/esm/features/jserrors/aggregate/canonical-function-name.js

@@ -0,0 +1,12 @@
+/*
+ * 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/dist/esm/features/jserrors/aggregate/canonical-function-name.test.js

@@ -0,0 +1,29 @@
+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', _ref => {
+  let {
+    input,
+    expected
+  } = _ref;
+  const result = canonicalFunctionName(input);
+  expect(result).toEqual(expected);
+});

package/dist/esm/features/jserrors/aggregate/compute-stack-trace.js

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