@newrelic/browser-agent 0.0.9 → 0.1.229

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

@@ -0,0 +1,257 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+var _testingUtils = require("../../../../tools/testing-utils");
+var _computeStackTrace = require("./compute-stack-trace");
+const baseMockError = {
+  toString: 'RangeError: Invalid array length',
+  name: 'RangeError',
+  constructor: 'function RangeError() { [native code] }',
+  message: 'Invalid array length',
+  stack: 'RangeError: Invalid array length\n    at errorTest (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:74:16)\n    at captureError (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:17:9)\n    at onload (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:70:5)'
+};
+test('parsing should return a failure for a null error object', () => {
+  const result = (0, _computeStackTrace.computeStackTrace)(null);
+  expect(result).toEqual(expect.objectContaining({
+    mode: 'failed',
+    stackString: '',
+    frames: []
+  }));
+});
+describe('errors with stack property', () => {
+  test('parsed name should be unknown when name and constructor are missing', () => {
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      ...baseMockError,
+      name: null,
+      constructor: null
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'stack',
+      name: 'unknown',
+      message: mockError.message,
+      stackString: mockError.stack
+    }));
+  });
+  test('parsed stack should not contain nrWrapper', () => {
+    const alteredError = baseMockError;
+    alteredError.stack += '\n    at nrWrapper (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:60:17)';
+    const mockError = _testingUtils.browserErrorUtils.constructError(alteredError);
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'stack',
+      name: mockError.name,
+      message: mockError.message,
+      stackString: expect.not.stringContaining('nrWrapper')
+    }));
+    expect(result.frames).not.toContainEqual(expect.objectContaining({
+      func: 'nrWrapper'
+    }));
+  });
+  test('stack should still parse when column numbers are missing', () => {
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      ...baseMockError,
+      stack: 'Error: Blocked a frame with origin "http://bam-test-1.nr-local.net:3334" from accessing a cross-origin frame.\n    at errorTest (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:60)\n    at captureError (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:17)\n    at onload (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:57)'
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'stack',
+      name: mockError.name,
+      message: mockError.message,
+      stackString: mockError.stack
+    }));
+    expect(result.frames.length).toEqual(3);
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      func: 'errorTest',
+      column: null
+    }));
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      func: 'captureError',
+      column: null
+    }));
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      func: 'onload',
+      column: null
+    }));
+  });
+  test('parser can handle chrome eval stack', () => {
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      ...baseMockError,
+      stack: '    at foobar (eval at foobar (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html))'
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'stack',
+      name: mockError.name,
+      message: mockError.message,
+      stackString: mockError.stack
+    }));
+    expect(result.frames.length).toEqual(1);
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      func: 'evaluated code'
+    }));
+  });
+  test('parser can handle ie eval stack', () => {
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      toString: 'TypeError: Permission denied',
+      name: 'TypeError',
+      constructor: '\nfunction TypeError() {\n    [native code]\n}\n',
+      message: 'Permission denied',
+      stack: '    at Function code (Function code:23:23)'
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'stack',
+      name: mockError.name,
+      message: mockError.message,
+      stackString: mockError.stack
+    }));
+    expect(result.frames.length).toEqual(1);
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      func: 'evaluated code'
+    }));
+  });
+  test('parser can handle stack with anonymous function', () => {
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      ...baseMockError,
+      stack: 'anonymous'
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'stack',
+      name: mockError.name,
+      message: mockError.message,
+      stackString: mockError.stack
+    }));
+    expect(result.frames.length).toEqual(1);
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      func: 'evaluated code'
+    }));
+  });
+});
+describe('errors without stack property and with line property', () => {
+  /**
+   * @deprecated sourceURL is no longer present in errors for any browsers we support
+   */
+  test('parsed stack should contain sourceURL and line number', () => {
+    const sourceURL = _faker.faker.internet.url();
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      ...baseMockError,
+      stack: undefined,
+      line: 100,
+      sourceURL
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'sourceline',
+      name: mockError.name,
+      message: mockError.message,
+      stackString: `${mockError.name}: ${mockError.message}\n    at ${sourceURL}:${mockError.line}`
+    }));
+    expect(result.frames.length).toEqual(1);
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      url: sourceURL,
+      line: mockError.line
+    }));
+  });
+
+  /**
+   * @deprecated sourceURL is no longer present in errors for any browsers we support
+   */
+  test('parsed stack should contain sourceURL, line number, and column number', () => {
+    const sourceURL = _faker.faker.internet.url();
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      ...baseMockError,
+      line: 100,
+      column: 200,
+      stack: undefined,
+      sourceURL
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'sourceline',
+      name: mockError.name,
+      message: mockError.message,
+      stackString: `${mockError.name}: ${mockError.message}\n    at ${sourceURL}:${mockError.line}:${mockError.column}`
+    }));
+    expect(result.frames.length).toEqual(1);
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      url: sourceURL,
+      line: mockError.line,
+      column: mockError.column
+    }));
+  });
+  test('parsed stack should contain "evaluated code" if sourceURL property is not present', () => {
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      ...baseMockError,
+      line: 100,
+      column: 200,
+      stack: undefined
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'sourceline',
+      name: mockError.name,
+      message: mockError.message,
+      stackString: `RangeError: ${mockError.message}\n    in evaluated code`
+    }));
+    expect(result.frames.length).toEqual(1);
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      func: 'evaluated code'
+    }));
+  });
+
+  // TODO: computeStackTraceBySourceAndLine does not respect firefox lineNumber and columnNumber properties when stack is empty
+});
+
+/**
+ * These tests are here because JS allows you to throw absolutely anything as an
+ * error, including primitives.
+ */
+describe('errors that are messages only or primitives', () => {
+  test('parser should get error name from constructor', () => {
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      toString: '0',
+      constructor: 'function Number() { [native code] }'
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'nameonly',
+      name: 'Number',
+      stackString: 'Number: undefined',
+      frames: []
+    }));
+  });
+  test('parser should get error name from name property', () => {
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      toString: '0',
+      name: _faker.faker.datatype.uuid(),
+      constructor: 'function Number() { [native code] }'
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'nameonly',
+      name: mockError.name,
+      stackString: `${mockError.name}: undefined`,
+      frames: []
+    }));
+  });
+  test('parser should include the message property', () => {
+    const mockError = _testingUtils.browserErrorUtils.constructError({
+      toString: '0',
+      name: _faker.faker.datatype.uuid(),
+      message: _faker.faker.datatype.uuid(),
+      constructor: 'function Number() { [native code] }'
+    });
+    const result = (0, _computeStackTrace.computeStackTrace)(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'nameonly',
+      name: mockError.name,
+      message: mockError.message,
+      stackString: `${mockError.name}: ${mockError.message}`,
+      frames: []
+    }));
+  });
+});
+
+// describe('')

package/dist/cjs/features/jserrors/aggregate/format-stack-trace.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatStackTrace = formatStackTrace;
+exports.truncateSize = truncateSize;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var stripNewlinesRegex = /^\n+|\n+$/g;
+var MAX_STACK_TRACE_LENGTH = 65530;
+function formatStackTrace(stackLines) {
+  return truncateStackLines(stackLines).replace(stripNewlinesRegex, '');
+}
+
+// takes array of stack lines and returns string with top 50 and buttom 50 lines
+function truncateStackLines(stackLines) {
+  var stackString;
+  if (stackLines.length > 100) {
+    var truncatedLines = stackLines.length - 100;
+    stackString = stackLines.slice(0, 50).join('\n');
+    stackString += '\n< ...truncated ' + truncatedLines + ' lines... >\n';
+    stackString += stackLines.slice(-50).join('\n');
+  } else {
+    stackString = stackLines.join('\n');
+  }
+  return stackString;
+}
+
+// truncates stack string to limit what is sent to backend
+function truncateSize(stackString) {
+  return stackString.length > MAX_STACK_TRACE_LENGTH ? stackString.substr(0, MAX_STACK_TRACE_LENGTH) : stackString;
+}

package/dist/cjs/features/jserrors/aggregate/format-stack-trace.test.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+var _formatStackTrace = require("./format-stack-trace");
+describe('formatStackTrace', () => {
+  test.each([{
+    input: ['line 1', 'line 2', 'line 3', 'line 4'],
+    expected: 'line 1\nline 2\nline 3\nline 4',
+    title: 'Appends all stack lines together'
+  }, {
+    input: ['', 'line 1', 'line 2'],
+    expected: 'line 1\nline 2',
+    title: 'Strips leading empty stack frame'
+  }, {
+    input: ['line 1', 'line 2', ''],
+    expected: 'line 1\nline 2',
+    title: 'Strips ending empty stack frame'
+  }])('$title', ({
+    input,
+    expected
+  }) => {
+    const result = (0, _formatStackTrace.formatStackTrace)(input);
+    expect(result).toEqual(expected);
+  });
+  test('truncates the middle of the stack lines when more than 100', () => {
+    const input = Array.apply(null, Array(200)).map(() => _faker.faker.datatype.uuid());
+    const expected = input.slice(0, 50).join('\n') + `\n< ...truncated ${input.length - 100} lines... >\n` + input.slice(-50).join('\n');
+    const result = (0, _formatStackTrace.formatStackTrace)(input);
+    expect(result).toEqual(expected);
+  });
+});
+describe('truncateSize', () => {
+  test('should truncate stack string to max limit', () => {
+    const maxSize = 65530;
+    const input = _faker.faker.datatype.string(maxSize + 1);
+    const result = (0, _formatStackTrace.truncateSize)(input);
+    expect(result).toEqual(input.slice(0, maxSize));
+  });
+});

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

@@ -0,0 +1,267 @@
+"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");
+var _load = require("../../../common/window/load");
+/*
+ * 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) {
+    super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
+    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', (...args) => this.storeError(...args), this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('ierr', (...args) => this.storeError(...args), this.featureName, this.ee);
+    const harvestTimeSeconds = (0, _config.getConfigurationValue)(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10;
+    const scheduler = new _harvestScheduler.HarvestScheduler('jserrors', {
+      onFinished: (...args) => this.onHarvestFinished(...args)
+    }, this);
+    scheduler.harvest.on('jserrors', (...args) => this.onHarvestStarted(...args));
+
+    // 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)();
+    if (!internal && (0, _config.getRuntime)(this.agentIdentifier).onerror && (0, _config.getRuntime)(this.agentIdentifier).onerror(err)) return;
+    var stackInfo = this.canonicalizeStackURLs((0, _computeStackTrace.computeStackTrace)(err));
+    var canonicalStack = this.buildCanonicalStackString(stackInfo);
+    var params = {
+      stackHash: (0, _stringHashCode.stringHashCode)(canonicalStack),
+      exceptionClass: stackInfo.name,
+      request_uri: _globalScope.globalScope?.location.pathname
+    };
+    if (stackInfo.message) {
+      params.message = '' + stackInfo.message;
+    }
+
+    /**
+     * 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)((0, _config.getRuntime)(this.agentIdentifier).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,26 @@
+"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', ({
+  input,
+  expected
+}) => {
+  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");