@newrelic/browser-agent 0.0.9 → 0.1.230

package/dist/cjs/features/ajax/instrument/distributed-tracing.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DT = void 0;
+var _config = require("../../../common/config/config");
+var _uniqueId = require("../../../common/ids/unique-id");
+var _parseUrl = require("../../../common/url/parse-url");
+var _globalScope = require("../../../common/util/global-scope");
+var _stringify = require("../../../common/util/stringify");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+class DT {
+  constructor(agentIdentifier) {
+    this.agentIdentifier = agentIdentifier;
+    // Binds this class instance context to the following fn used in an external module (exported);
+    //  Alternatively, can make them class field arrow functions, but requires experimental features/plugin for eslint.
+    this.generateTracePayload = this.generateTracePayload.bind(this);
+    this.shouldGenerateTrace = this.shouldGenerateTrace.bind(this);
+  }
+  generateTracePayload(parsedOrigin) {
+    if (!this.shouldGenerateTrace(parsedOrigin)) {
+      return null;
+    }
+    var loader_config = (0, _config.getLoaderConfig)(this.agentIdentifier);
+    if (!loader_config) {
+      return null;
+    }
+    var accountId = (loader_config.accountID || '').toString() || null;
+    var agentId = (loader_config.agentID || '').toString() || null;
+    var trustKey = (loader_config.trustKey || '').toString() || null;
+    if (!accountId || !agentId) {
+      return null;
+    }
+    var spanId = (0, _uniqueId.generateSpanId)();
+    var traceId = (0, _uniqueId.generateTraceId)();
+    var timestamp = Date.now();
+    var payload = {
+      spanId: spanId,
+      traceId: traceId,
+      timestamp: timestamp
+    };
+    if (parsedOrigin.sameOrigin || this.isAllowedOrigin(parsedOrigin) && this.useTraceContextHeadersForCors()) {
+      payload.traceContextParentHeader = this.generateTraceContextParentHeader(spanId, traceId);
+      payload.traceContextStateHeader = this.generateTraceContextStateHeader(spanId, timestamp, accountId, agentId, trustKey);
+    }
+    if (parsedOrigin.sameOrigin && !this.excludeNewrelicHeader() || !parsedOrigin.sameOrigin && this.isAllowedOrigin(parsedOrigin) && this.useNewrelicHeaderForCors()) {
+      payload.newrelicHeader = this.generateTraceHeader(spanId, traceId, timestamp, accountId, agentId, trustKey);
+    }
+    return payload;
+  }
+  generateTraceContextParentHeader(spanId, traceId) {
+    return '00-' + traceId + '-' + spanId + '-01';
+  }
+  generateTraceContextStateHeader(spanId, timestamp, accountId, appId, trustKey) {
+    var version = 0;
+    var transactionId = '';
+    var parentType = 1;
+    var sampled = '';
+    var priority = '';
+    return trustKey + '@nr=' + version + '-' + parentType + '-' + accountId + '-' + appId + '-' + spanId + '-' + transactionId + '-' + sampled + '-' + priority + '-' + timestamp;
+  }
+  generateTraceHeader(spanId, traceId, timestamp, accountId, appId, trustKey) {
+    var hasBtoa = typeof _globalScope.globalScope?.btoa === 'function';
+    if (!hasBtoa) {
+      return null;
+    }
+    var payload = {
+      v: [0, 1],
+      d: {
+        ty: 'Browser',
+        ac: accountId,
+        ap: appId,
+        id: spanId,
+        tr: traceId,
+        ti: timestamp
+      }
+    };
+    if (trustKey && accountId !== trustKey) {
+      payload.d.tk = trustKey;
+    }
+    return btoa((0, _stringify.stringify)(payload));
+  }
+
+  // return true if DT is enabled and the origin is allowed, either by being
+  // same-origin, or included in the allowed list
+  shouldGenerateTrace(parsedOrigin) {
+    return this.isDtEnabled() && this.isAllowedOrigin(parsedOrigin);
+  }
+  isAllowedOrigin(parsedOrigin) {
+    var allowed = false;
+    var dtConfig = {};
+    var dt = (0, _config.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
+    if (dt) {
+      dtConfig = (0, _config.getConfiguration)(this.agentIdentifier).distributed_tracing;
+    }
+    if (parsedOrigin.sameOrigin) {
+      allowed = true;
+    } else if (dtConfig.allowed_origins instanceof Array) {
+      for (var i = 0; i < dtConfig.allowed_origins.length; i++) {
+        var allowedOrigin = (0, _parseUrl.parseUrl)(dtConfig.allowed_origins[i]);
+        if (parsedOrigin.hostname === allowedOrigin.hostname && parsedOrigin.protocol === allowedOrigin.protocol && parsedOrigin.port === allowedOrigin.port) {
+          allowed = true;
+          break;
+        }
+      }
+    }
+    return allowed;
+  }
+  isDtEnabled() {
+    var dt = (0, _config.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
+    if (dt) {
+      return !!dt.enabled;
+    }
+    return false;
+  }
+
+  // exclude the newrelic header for same-origin calls
+  excludeNewrelicHeader() {
+    var dt = (0, _config.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
+    if (dt) {
+      return !!dt.exclude_newrelic_header;
+    }
+    return false;
+  }
+  useNewrelicHeaderForCors() {
+    var dt = (0, _config.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
+    if (dt) {
+      return dt.cors_use_newrelic_header !== false;
+    }
+    return false;
+  }
+  useTraceContextHeadersForCors() {
+    var dt = (0, _config.getConfigurationValue)(this.agentIdentifier, 'distributed_tracing');
+    if (dt) {
+      return !!dt.cors_use_tracecontext_headers;
+    }
+    return false;
+  }
+}
+exports.DT = DT;

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

@@ -0,0 +1,339 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Instrument = void 0;
+var _config = require("../../../common/config/config");
+var _handle = require("../../../common/event-emitter/handle");
+var _id = require("../../../common/ids/id");
+var _firefoxVersion = require("../../../common/browser-version/firefox-version");
+var _dataSize = require("../../../common/util/data-size");
+var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
+var _now = require("../../../common/timing/now");
+var _wrap = require("../../../common/wrap");
+var _parseUrl = require("../../../common/url/parse-url");
+var _distributedTracing = require("./distributed-tracing");
+var _responseSize = require("./response-size");
+var _instrumentBase = require("../../utils/instrument-base");
+var _constants = require("../constants");
+var _features = require("../../../loaders/features/features");
+var _globalScope = require("../../../common/util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var handlers = ['load', 'error', 'abort', 'timeout'];
+var handlersLen = handlers.length;
+var origRequest = _config.originals.REQ;
+var origXHR = _globalScope.globalScope.XMLHttpRequest;
+class Instrument extends _instrumentBase.InstrumentBase {
+  static featureName = _constants.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    super(agentIdentifier, aggregator, _constants.FEATURE_NAME, auto);
+
+    // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
+    if (!(0, _config.getRuntime)(agentIdentifier).xhrWrappable) return;
+    this.dt = new _distributedTracing.DT(agentIdentifier);
+    this.handler = (type, args, ctx, group) => (0, _handle.handle)(type, args, ctx, group, this.ee);
+    (0, _wrap.wrapFetch)(this.ee);
+    (0, _wrap.wrapXhr)(this.ee);
+    subscribeToEvents(agentIdentifier, this.ee, this.handler, this.dt);
+    this.importAggregator();
+  }
+}
+exports.Instrument = Instrument;
+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);
+    }, (0, _eventListenerOpts.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 (_firefoxVersion.ffVersion) return;
+    xhr.addEventListener('progress', function (event) {
+      ctx.lastSize = event.loaded;
+    }, (0, _eventListenerOpts.eventListenerOpts)(false));
+  }
+  function onOpenXhrStart(args) {
+    this.params = {
+      method: args[0]
+    };
+    addUrl(this, args[1]);
+    this.metrics = {};
+  }
+  function onOpenXhrEnd(args, xhr) {
+    var loader_config = (0, _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 = (0, _dataSize.dataSize)(data);
+      if (size) metrics.txSize = size;
+    }
+    this.startTime = (0, _now.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, (0, _eventListenerOpts.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 = '' + (0, _id.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 = '' + (0, _id.id)(cb) + !!useCapture;
+    if (!this.xhrGuids || !this.xhrGuids[idString]) return;
+    delete this.xhrGuids[idString];
+    this.totalCbs -= 1;
+  }
+  function onXhrResolved() {
+    this.endTime = (0, _now.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 = (0, _now.now)();
+    }
+  }
+  function onFnEnd(args, xhr) {
+    if (this.xhrCbStart) ee.emit('xhr-cb-time', [(0, _now.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.globalScope?.URL && args[0] && args[0] instanceof URL) {
+      url = args[0].href;
+    }
+    if (url) {
+      this.parsedOrigin = (0, _parseUrl.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.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 = (0, _now.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.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 = (0, _dataSize.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 = (0, _now.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: (0, _now.now)() - this.startTime
+    };
+    handler('xhr', [this.params, metrics, this.startTime, this.endTime, 'fetch'], this, _features.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 = (0, _now.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, _features.FEATURE_NAMES.ajax);
+  }
+  function addUrl(ctx, url) {
+    var parsed = (0, _parseUrl.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 = (0, _responseSize.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/cjs/features/ajax/instrument/response-size.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.responseSizeFromXhr = responseSizeFromXhr;
+var _dataSize = require("../../../common/util/data-size");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+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 (0, _dataSize.dataSize)(xhr.response);
+  } else if (type === 'text' || type === '' || type === undefined) {
+    // empty string type defaults to 'text'
+    return (0, _dataSize.dataSize)(xhr.responseText);
+  } else {
+    // e.g. ms-stream and document (we do not currently determine the size of Document objects)
+    return undefined;
+  }
+}

package/dist/cjs/features/jserrors/aggregate/canonical-function-name.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canonicalFunctionName = canonicalFunctionName;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var canonicalFunctionNameRe = /([a-z0-9]+)$/i;
+function canonicalFunctionName(orig) {
+  if (!orig) return;
+  var match = orig.match(canonicalFunctionNameRe);
+  if (match) return match[1];
+  return;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+
+var _canonicalFunctionName = require("./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 = (0, _canonicalFunctionName.canonicalFunctionName)(input);
+  expect(result).toEqual(expected);
+});