@newrelic/browser-agent 0.0.9 → 0.1.230

package/dist/cjs/features/jserrors/aggregate/index.js

@@ -0,0 +1,288 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Aggregate = void 0;
+var _canonicalFunctionName = require("./canonical-function-name");
+var _cleanUrl = require("../../../common/url/clean-url");
+var _computeStackTrace = require("./compute-stack-trace");
+var _stringHashCode = require("./string-hash-code");
+var _formatStackTrace = require("./format-stack-trace");
+var _registerHandler = require("../../../common/event-emitter/register-handler");
+var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
+var _stringify = require("../../../common/util/stringify");
+var _handle = require("../../../common/event-emitter/handle");
+var _mapOwn = require("../../../common/util/map-own");
+var _config = require("../../../common/config/config");
+var _now = require("../../../common/timing/now");
+var _globalScope = require("../../../common/util/global-scope");
+var _aggregateBase = require("../../utils/aggregate-base");
+var _constants = require("../constants");
+var _drain = require("../../../common/drain/drain");
+var _features = require("../../../loaders/features/features");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+class Aggregate extends _aggregateBase.AggregateBase {
+  static featureName = _constants.FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    var _this;
+    super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
+    _this = this;
+    this.stackReported = {};
+    this.pageviewReported = {};
+    this.errorCache = {};
+    this.currentBody;
+    this.errorOnPage = false;
+
+    // this will need to change to match whatever ee we use in the instrument
+    this.ee.on('interactionSaved', interaction => this.onInteractionSaved(interaction));
+
+    // this will need to change to match whatever ee we use in the instrument
+    this.ee.on('interactionDiscarded', interaction => this.onInteractionDiscarded(interaction));
+    (0, _registerHandler.registerHandler)('err', function () {
+      return _this.storeError(...arguments);
+    }, this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('ierr', function () {
+      return _this.storeError(...arguments);
+    }, this.featureName, this.ee);
+    const harvestTimeSeconds = (0, _config.getConfigurationValue)(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10;
+    const scheduler = new _harvestScheduler.HarvestScheduler('jserrors', {
+      onFinished: function () {
+        return _this.onHarvestFinished(...arguments);
+      }
+    }, this);
+    scheduler.harvest.on('jserrors', function () {
+      return _this.onHarvestStarted(...arguments);
+    });
+
+    // Don't start harvesting until "drain" for this feat has been called (which currently requires RUM response).
+    this.ee.on(`drain-${this.featureName}`, () => {
+      if (!this.blocked) scheduler.startTimer(harvestTimeSeconds); // and only if ingest will accept jserror payloads
+    });
+
+    // If RUM-call's response determines that customer lacks entitlements for the /jserror ingest endpoint, don't harvest at all.
+    (0, _registerHandler.registerHandler)('block-err', () => {
+      this.blocked = true;
+      scheduler.stopTimer(true);
+    }, this.featureName, this.ee);
+    (0, _drain.drain)(this.agentIdentifier, this.featureName);
+  }
+  onHarvestStarted(options) {
+    // this gets rid of dependency in AJAX module
+    var body = this.aggregator.take(['err', 'ierr', 'xhr']);
+    if (options.retry) {
+      this.currentBody = body;
+    }
+    var payload = {
+      body: body,
+      qs: {}
+    };
+    var releaseIds = (0, _stringify.stringify)((0, _config.getRuntime)(this.agentIdentifier).releaseIds);
+    if (releaseIds !== '{}') {
+      payload.qs.ri = releaseIds;
+    }
+    if (body && body.err && body.err.length && !this.errorOnPage) {
+      payload.qs.pve = '1';
+      this.errorOnPage = true;
+    }
+    return payload;
+  }
+  onHarvestFinished(result) {
+    if (result.retry && this.currentBody) {
+      (0, _mapOwn.mapOwn)(this.currentBody, (key, value) => {
+        for (var i = 0; i < value.length; i++) {
+          var bucket = value[i];
+          var name = this.getBucketName(bucket.params, bucket.custom);
+          this.aggregator.merge(key, name, bucket.metrics, bucket.params, bucket.custom);
+        }
+      });
+      this.currentBody = null;
+    }
+  }
+  nameHash(params) {
+    return (0, _stringHashCode.stringHashCode)(`${params.exceptionClass}_${params.message}_${params.stack_trace || params.browser_stack_hash}`);
+  }
+  getBucketName(params, customParams) {
+    return this.nameHash(params) + ':' + (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(customParams));
+  }
+  canonicalizeURL(url, cleanedOrigin) {
+    if (typeof url !== 'string') return '';
+    var cleanedURL = (0, _cleanUrl.cleanURL)(url);
+    if (cleanedURL === cleanedOrigin) {
+      return '<inline>';
+    } else {
+      return cleanedURL;
+    }
+  }
+  buildCanonicalStackString(stackInfo, cleanedOrigin) {
+    var canonicalStack = '';
+    for (var i = 0; i < stackInfo.frames.length; i++) {
+      var frame = stackInfo.frames[i];
+      var func = (0, _canonicalFunctionName.canonicalFunctionName)(frame.func);
+      if (canonicalStack) canonicalStack += '\n';
+      if (func) canonicalStack += func + '@';
+      if (typeof frame.url === 'string') canonicalStack += frame.url;
+      if (frame.line) canonicalStack += ':' + frame.line;
+    }
+    return canonicalStack;
+  }
+
+  // Strip query parameters and fragments from the stackString property of the
+  // given stackInfo, along with the 'url' properties of each frame in
+  // stackInfo.frames.
+  //
+  // Any URLs that are equivalent to the cleaned version of the origin will also
+  // be replaced with the string '<inline>'.
+  //
+  canonicalizeStackURLs(stackInfo) {
+    // Currently, loader.origin might contain a fragment, but we don't want to use it
+    // for comparing with frame URLs.
+    var cleanedOrigin = (0, _cleanUrl.cleanURL)((0, _config.getRuntime)(this.agentIdentifier).origin);
+    for (var i = 0; i < stackInfo.frames.length; i++) {
+      var frame = stackInfo.frames[i];
+      var originalURL = frame.url;
+      var cleanedURL = this.canonicalizeURL(originalURL, cleanedOrigin);
+      if (cleanedURL && cleanedURL !== frame.url) {
+        frame.url = cleanedURL;
+        stackInfo.stackString = stackInfo.stackString.split(originalURL).join(cleanedURL);
+      }
+    }
+    return stackInfo;
+  }
+  storeError(err, time, internal, customAttributes) {
+    // are we in an interaction
+    time = time || (0, _now.now)();
+    const agentRuntime = (0, _config.getRuntime)(this.agentIdentifier);
+    let filterOutput;
+    if (!internal && agentRuntime.onerror) {
+      filterOutput = agentRuntime.onerror(err);
+      if (filterOutput && !(typeof filterOutput.group === 'string' && filterOutput.group.length)) {
+        // All truthy values mean don't report (store) the error, per backwards-compatible usage,
+        // - EXCEPT if a fingerprinting label is returned, via an object with key of 'group' and value of non-empty string
+        return;
+      }
+      // Again as with previous usage, all falsey values would include the error.
+    }
+
+    var stackInfo = this.canonicalizeStackURLs((0, _computeStackTrace.computeStackTrace)(err));
+    var canonicalStack = this.buildCanonicalStackString(stackInfo);
+    const params = {
+      stackHash: (0, _stringHashCode.stringHashCode)(canonicalStack),
+      exceptionClass: stackInfo.name,
+      request_uri: _globalScope.globalScope?.location.pathname
+    };
+    if (stackInfo.message) params.message = '' + stackInfo.message;
+    // Notice if filterOutput isn't false|undefined OR our specified object, this func would've returned already (so it's unnecessary to req-check group).
+    // Do not modify the name ('errorGroup') of params without DEM approval!
+    if (filterOutput?.group) params.errorGroup = filterOutput.group;
+
+    /**
+     * The bucketHash is different from the params.stackHash because the params.stackHash is based on the canonicalized
+     * stack trace and is used downstream in NR1 to attempt to group the same errors across different browsers. However,
+     * the canonical stack trace excludes items like the column number increasing the hit-rate of different errors potentially
+     * bucketing and ultimately resulting in the loss of data in NR1.
+     */
+    var bucketHash = (0, _stringHashCode.stringHashCode)(`${stackInfo.name}_${stackInfo.message}_${stackInfo.stackString}`);
+    if (!this.stackReported[bucketHash]) {
+      this.stackReported[bucketHash] = true;
+      params.stack_trace = (0, _formatStackTrace.truncateSize)(stackInfo.stackString);
+    } else {
+      params.browser_stack_hash = (0, _stringHashCode.stringHashCode)(stackInfo.stackString);
+    }
+    params.releaseIds = (0, _stringify.stringify)(agentRuntime.releaseIds);
+
+    // When debugging stack canonicalization/hashing, uncomment these lines for
+    // more output in the test logs
+    // params.origStack = err.stack
+    // params.canonicalStack = canonicalStack
+
+    if (!this.pageviewReported[bucketHash]) {
+      params.pageview = 1;
+      this.pageviewReported[bucketHash] = true;
+    }
+    var type = internal ? 'ierr' : 'err';
+    var newMetrics = {
+      time: time
+    };
+
+    // stn and spa aggregators listen to this event - stn sends the error in its payload,
+    // and spa annotates the error with interaction info
+    (0, _handle.handle)('errorAgg', [type, bucketHash, params, newMetrics], undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
+    (0, _handle.handle)('errorAgg', [type, bucketHash, params, newMetrics], undefined, _features.FEATURE_NAMES.spa, this.ee);
+
+    // still send EE events for other features such as above, but stop this one from aggregating internal data
+    if (this.blocked) return;
+    if (params._interactionId != null) {
+      // hold on to the error until the interaction finishes
+      this.errorCache[params._interactionId] = this.errorCache[params._interactionId] || [];
+      this.errorCache[params._interactionId].push([type, bucketHash, params, newMetrics, att, customAttributes]);
+    } else {
+      // store custom attributes
+      var customParams = {};
+      var att = (0, _config.getInfo)(this.agentIdentifier).jsAttributes;
+      (0, _mapOwn.mapOwn)(att, setCustom);
+      if (customAttributes) {
+        (0, _mapOwn.mapOwn)(customAttributes, setCustom);
+      }
+      var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(customParams));
+      var aggregateHash = bucketHash + ':' + jsAttributesHash;
+      this.aggregator.store(type, aggregateHash, params, newMetrics, customParams);
+    }
+    function setCustom(key, val) {
+      customParams[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
+    }
+  }
+  onInteractionSaved(interaction) {
+    if (!this.errorCache[interaction.id] || this.blocked) return;
+    this.errorCache[interaction.id].forEach(item => {
+      var customParams = {};
+      var globalCustomParams = item[4];
+      var localCustomParams = item[5];
+      (0, _mapOwn.mapOwn)(globalCustomParams, setCustom);
+      (0, _mapOwn.mapOwn)(interaction.root.attrs.custom, setCustom);
+      (0, _mapOwn.mapOwn)(localCustomParams, setCustom);
+      var params = item[2];
+      params.browserInteractionId = interaction.root.attrs.id;
+      delete params._interactionId;
+      if (params._interactionNodeId) {
+        params.parentNodeId = params._interactionNodeId.toString();
+        delete params._interactionNodeId;
+      }
+      var hash = item[1] + interaction.root.attrs.id;
+      var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(customParams));
+      var aggregateHash = hash + ':' + jsAttributesHash;
+      this.aggregator.store(item[0], aggregateHash, params, item[3], customParams);
+      function setCustom(key, val) {
+        customParams[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
+      }
+    });
+    delete this.errorCache[interaction.id];
+  }
+  onInteractionDiscarded(interaction) {
+    if (!this.errorCache || !this.errorCache[interaction.id] || this.blocked) return;
+    this.errorCache[interaction.id].forEach(item => {
+      var customParams = {};
+      var globalCustomParams = item[4];
+      var localCustomParams = item[5];
+      (0, _mapOwn.mapOwn)(globalCustomParams, setCustom);
+      (0, _mapOwn.mapOwn)(interaction.root.attrs.custom, setCustom);
+      (0, _mapOwn.mapOwn)(localCustomParams, setCustom);
+      var params = item[2];
+      delete params._interactionId;
+      delete params._interactionNodeId;
+      var hash = item[1];
+      var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(customParams));
+      var aggregateHash = hash + ':' + jsAttributesHash;
+      this.aggregator.store(item[0], aggregateHash, item[2], item[3], customParams);
+      function setCustom(key, val) {
+        customParams[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
+      }
+    });
+    delete this.errorCache[interaction.id];
+  }
+}
+exports.Aggregate = Aggregate;

package/dist/cjs/features/jserrors/aggregate/string-hash-code.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stringHashCode = stringHashCode;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+function stringHashCode(string) {
+  var hash = 0;
+  var charVal;
+  if (!string || !string.length) return hash;
+  for (var i = 0; i < string.length; i++) {
+    charVal = string.charCodeAt(i);
+    hash = (hash << 5) - hash + charVal;
+    hash = hash | 0; // Convert to 32bit integer
+  }
+
+  return hash;
+}

package/dist/cjs/features/jserrors/aggregate/string-hash-code.test.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _stringHashCode = require("./string-hash-code");
+test.each([{
+  input: undefined,
+  expected: 0,
+  title: 'Return 0 for undefined input'
+}, {
+  input: null,
+  expected: 0,
+  title: 'Return 0 for null input'
+}, {
+  input: '',
+  expected: 0,
+  title: 'Return 0 for empty string input'
+}, {
+  input: 'lksjdflksjdf',
+  expected: 32668720,
+  title: 'Return valid hash of string'
+}])('$title', _ref => {
+  let {
+    input,
+    expected
+  } = _ref;
+  const result = (0, _stringHashCode.stringHashCode)(input);
+  expect(result).toEqual(expected);
+});

package/dist/cjs/features/jserrors/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NR_ERR_PROP = exports.FEATURE_NAME = void 0;
+var _features = require("../../loaders/features/features");
+const FEATURE_NAME = _features.FEATURE_NAMES.jserrors;
+exports.FEATURE_NAME = FEATURE_NAME;
+const NR_ERR_PROP = 'nr@seenError';
+exports.NR_ERR_PROP = NR_ERR_PROP;

package/dist/cjs/features/jserrors/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "JSErrors", {
+  enumerable: true,
+  get: function () {
+    return _index.Instrument;
+  }
+});
+var _index = require("./instrument/index");

package/dist/cjs/features/jserrors/instrument/debug.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _contextualEe = require("../../../common/event-emitter/contextual-ee");
+var _mapOwn = require("../../../common/util/map-own");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var flags = {};
+var flagArr;
+try {
+  flagArr = localStorage.getItem('__nr_flags').split(',');
+  if (console && typeof console.log === 'function') {
+    flags.console = true;
+    if (flagArr.indexOf('dev') !== -1) flags.dev = true;
+    if (flagArr.indexOf('nr_dev') !== -1) flags.nrDev = true;
+  }
+} catch (err) {
+  // no op
+}
+if (flags.nrDev) _contextualEe.ee.on('internal-error', function (err) {
+  log(err.stack);
+});
+if (flags.dev) _contextualEe.ee.on('fn-err', function (args, origThis, err) {
+  log(err.stack);
+});
+if (flags.dev) {
+  log('NR AGENT IN DEVELOPMENT MODE');
+  log('flags: ' + (0, _mapOwn.mapOwn)(flags, function (key, val) {
+    return key;
+  }).join(', '));
+}
+function log(message) {
+  try {
+    if (flags.console) log(message);
+  } catch (err) {
+    // no op
+  }
+}

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

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Instrument = void 0;
+var _handle = require("../../../common/event-emitter/handle");
+var _now = require("../../../common/timing/now");
+var _getOrSet = require("../../../common/util/get-or-set");
+var _wrap = require("../../../common/wrap");
+var _lodash = _interopRequireDefault(require("lodash._slice"));
+require("./debug");
+var _instrumentBase = require("../../utils/instrument-base");
+var _constants = require("../constants");
+var _features = require("../../../loaders/features/features");
+var _globalScope = require("../../../common/util/global-scope");
+var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
+var _config = require("../../../common/config/config");
+var _stringify = require("../../../common/util/stringify");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+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);
+    // skipNext counter to keep track of uncaught
+    // errors that will be the same as caught errors.
+    this.skipNext = 0;
+    try {
+      this.removeOnAbort = new AbortController();
+    } // this try-catch can be removed when IE11 is completely unsupported & gone
+    catch (e) {}
+    const thisInstrument = this;
+    thisInstrument.ee.on('fn-start', function (args, obj, methodName) {
+      if (thisInstrument.abortHandler) thisInstrument.skipNext += 1;
+    });
+    thisInstrument.ee.on('fn-err', function (args, obj, err) {
+      if (thisInstrument.abortHandler && !err[_constants.NR_ERR_PROP]) {
+        (0, _getOrSet.getOrSet)(err, _constants.NR_ERR_PROP, function getVal() {
+          return true;
+        });
+        this.thrown = true;
+        notice(err, undefined, thisInstrument.ee);
+      }
+    });
+    thisInstrument.ee.on('fn-end', function () {
+      if (!thisInstrument.abortHandler) return;
+      if (!this.thrown && thisInstrument.skipNext > 0) thisInstrument.skipNext -= 1;
+    });
+    thisInstrument.ee.on('internal-error', function (e) {
+      (0, _handle.handle)('ierr', [e, (0, _now.now)(), true], undefined, _features.FEATURE_NAMES.jserrors, thisInstrument.ee);
+    });
+
+    // Replace global error handler with our own.
+    this.origOnerror = _globalScope.globalScope.onerror;
+    _globalScope.globalScope.onerror = this.onerrorHandler.bind(this);
+    _globalScope.globalScope.addEventListener('unhandledrejection', e => {
+      /** rejections can contain data of any type -- this is an effort to keep the message human readable */
+      const err = castReasonToError(e.reason);
+      (0, _handle.handle)('err', [err, (0, _now.now)(), false, {
+        unhandledPromiseRejection: 1
+      }], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+    }, (0, _eventListenerOpts.eventListenerOpts)(false, this.removeOnAbort?.signal));
+    (0, _wrap.wrapRaf)(this.ee);
+    (0, _wrap.wrapTimer)(this.ee);
+    (0, _wrap.wrapEvents)(this.ee);
+    if ((0, _config.getRuntime)(agentIdentifier).xhrWrappable) (0, _wrap.wrapXhr)(this.ee);
+    this.abortHandler = this.#abort; // we also use this as a flag to denote that the feature is active or on and handling errors
+    this.importAggregator();
+  }
+
+  /** Restoration and resource release tasks to be done if JS error loader is being aborted. Unwind changes to globals. */
+  #abort() {
+    this.removeOnAbort?.abort();
+    this.abortHandler = undefined; // weakly allow this abort op to run only once
+  }
+
+  /**
+   * FF and Android browsers do not provide error info to the 'error' event callback,
+   * so we must use window.onerror
+   * @param {string} message
+   * @param {string} filename
+   * @param {number} lineno
+   * @param {number} column
+   * @param {Error | *} errorObj
+   * @returns
+   */
+  onerrorHandler(message, filename, lineno, column, errorObj) {
+    if (typeof this.origOnerror === 'function') this.origOnerror(...arguments);
+    try {
+      if (this.skipNext) this.skipNext -= 1;else notice(errorObj || new UncaughtException(message, filename, lineno), true, this.ee);
+    } catch (e) {
+      try {
+        (0, _handle.handle)('ierr', [e, (0, _now.now)(), true], undefined, _features.FEATURE_NAMES.jserrors, this.ee);
+      } catch (err) {
+        // do nothing
+      }
+    }
+    return false; // maintain default behavior of the error event of Window
+  }
+}
+
+/**
+ *
+ * @param {string} message
+ * @param {string} filename
+ * @param {number} lineno
+ */
+exports.Instrument = Instrument;
+function UncaughtException(message, filename, lineno) {
+  this.message = message || 'Uncaught error with no additional information';
+  this.sourceURL = filename;
+  this.line = lineno;
+}
+
+/**
+ * Adds a timestamp and emits the 'err' event, which the error aggregator listens for
+ * @param {Error} err
+ * @param {boolean} doNotStamp
+ * @param {ContextualEE} ee
+ */
+function notice(err, doNotStamp, ee) {
+  // by default add timestamp, unless specifically told not to
+  // this is to preserve existing behavior
+  var time = !doNotStamp ? (0, _now.now)() : null;
+  (0, _handle.handle)('err', [err, time], undefined, _features.FEATURE_NAMES.jserrors, ee);
+}
+
+/**
+ * Attempts to cast an unhandledPromiseRejection reason (reject(...)) to an Error object
+ * @param {*} reason - The reason property from an unhandled promise rejection
+ * @returns {Error} - An Error object with the message as the casted reason
+ */
+function castReasonToError(reason) {
+  let prefix = 'Unhandled Promise Rejection: ';
+  if (reason instanceof Error) {
+    try {
+      reason.message = prefix + reason.message;
+      return reason;
+    } catch (e) {
+      return reason;
+    }
+  }
+  if (typeof reason === 'undefined') return new Error(prefix);
+  try {
+    return new Error(prefix + (0, _stringify.stringify)(reason));
+  } catch (err) {
+    return new Error(prefix);
+  }
+}