@newrelic/browser-agent 0.0.9 → 0.1.229

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

@@ -0,0 +1,255 @@
+import { faker } from '@faker-js/faker';
+import { browserErrorUtils } from '../../../../tools/testing-utils';
+import { computeStackTrace } from './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 = 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 = browserErrorUtils.constructError({
+      ...baseMockError,
+      name: null,
+      constructor: null
+    });
+    const result = 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 = browserErrorUtils.constructError(alteredError);
+    const result = 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 = 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 = 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 = browserErrorUtils.constructError({
+      ...baseMockError,
+      stack: '    at foobar (eval at foobar (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html))'
+    });
+    const result = 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 = 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 = 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 = browserErrorUtils.constructError({
+      ...baseMockError,
+      stack: 'anonymous'
+    });
+    const result = 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.internet.url();
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError,
+      stack: undefined,
+      line: 100,
+      sourceURL
+    });
+    const result = 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.internet.url();
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError,
+      line: 100,
+      column: 200,
+      stack: undefined,
+      sourceURL
+    });
+    const result = 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 = browserErrorUtils.constructError({
+      ...baseMockError,
+      line: 100,
+      column: 200,
+      stack: undefined
+    });
+    const result = 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 = browserErrorUtils.constructError({
+      toString: '0',
+      constructor: 'function Number() { [native code] }'
+    });
+    const result = 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 = browserErrorUtils.constructError({
+      toString: '0',
+      name: faker.datatype.uuid(),
+      constructor: 'function Number() { [native code] }'
+    });
+    const result = 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 = browserErrorUtils.constructError({
+      toString: '0',
+      name: faker.datatype.uuid(),
+      message: faker.datatype.uuid(),
+      constructor: 'function Number() { [native code] }'
+    });
+    const result = computeStackTrace(mockError);
+    expect(result).toEqual(expect.objectContaining({
+      mode: 'nameonly',
+      name: mockError.name,
+      message: mockError.message,
+      stackString: `${mockError.name}: ${mockError.message}`,
+      frames: []
+    }));
+  });
+});
+
+// describe('')

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

@@ -0,0 +1,29 @@
+/*
+ * 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;
+export 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
+export function truncateSize(stackString) {
+  return stackString.length > MAX_STACK_TRACE_LENGTH ? stackString.substr(0, MAX_STACK_TRACE_LENGTH) : stackString;
+}

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

@@ -0,0 +1,37 @@
+import { faker } from '@faker-js/faker';
+import { formatStackTrace, truncateSize } from './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 = 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.datatype.uuid());
+    const expected = input.slice(0, 50).join('\n') + `\n< ...truncated ${input.length - 100} lines... >\n` + input.slice(-50).join('\n');
+    const result = formatStackTrace(input);
+    expect(result).toEqual(expected);
+  });
+});
+describe('truncateSize', () => {
+  test('should truncate stack string to max limit', () => {
+    const maxSize = 65530;
+    const input = faker.datatype.string(maxSize + 1);
+    const result = truncateSize(input);
+    expect(result).toEqual(input.slice(0, maxSize));
+  });
+});

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

@@ -0,0 +1,260 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { canonicalFunctionName } from './canonical-function-name';
+import { cleanURL } from '../../../common/url/clean-url';
+import { computeStackTrace } from './compute-stack-trace';
+import { stringHashCode } from './string-hash-code';
+import { truncateSize } from './format-stack-trace';
+import { registerHandler as register } from '../../../common/event-emitter/register-handler';
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
+import { stringify } from '../../../common/util/stringify';
+import { handle } from '../../../common/event-emitter/handle';
+import { mapOwn } from '../../../common/util/map-own';
+import { getInfo, getConfigurationValue, getRuntime } from '../../../common/config/config';
+import { now } from '../../../common/timing/now';
+import { globalScope } from '../../../common/util/global-scope';
+import { AggregateBase } from '../../utils/aggregate-base';
+import { FEATURE_NAME } from '../constants';
+import { drain } from '../../../common/drain/drain';
+import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { onWindowLoad } from '../../../common/window/load';
+export class Aggregate extends AggregateBase {
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, 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));
+    register('err', (...args) => this.storeError(...args), this.featureName, this.ee);
+    register('ierr', (...args) => this.storeError(...args), this.featureName, this.ee);
+    const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10;
+    const scheduler = new 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.
+    register('block-err', () => {
+      this.blocked = true;
+      scheduler.stopTimer(true);
+    }, this.featureName, this.ee);
+    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 = stringify(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) {
+      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 stringHashCode(`${params.exceptionClass}_${params.message}_${params.stack_trace || params.browser_stack_hash}`);
+  }
+  getBucketName(params, customParams) {
+    return this.nameHash(params) + ':' + stringHashCode(stringify(customParams));
+  }
+  canonicalizeURL(url, cleanedOrigin) {
+    if (typeof url !== 'string') return '';
+    var cleanedURL = 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 = 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 = cleanURL(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 || now();
+    if (!internal && getRuntime(this.agentIdentifier).onerror && getRuntime(this.agentIdentifier).onerror(err)) return;
+    var stackInfo = this.canonicalizeStackURLs(computeStackTrace(err));
+    var canonicalStack = this.buildCanonicalStackString(stackInfo);
+    var params = {
+      stackHash: stringHashCode(canonicalStack),
+      exceptionClass: stackInfo.name,
+      request_uri: 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 = stringHashCode(`${stackInfo.name}_${stackInfo.message}_${stackInfo.stackString}`);
+    if (!this.stackReported[bucketHash]) {
+      this.stackReported[bucketHash] = true;
+      params.stack_trace = truncateSize(stackInfo.stackString);
+    } else {
+      params.browser_stack_hash = stringHashCode(stackInfo.stackString);
+    }
+    params.releaseIds = stringify(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
+    handle('errorAgg', [type, bucketHash, params, newMetrics], undefined, FEATURE_NAMES.sessionTrace, this.ee);
+    handle('errorAgg', [type, bucketHash, params, newMetrics], undefined, 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 = getInfo(this.agentIdentifier).jsAttributes;
+      mapOwn(att, setCustom);
+      if (customAttributes) {
+        mapOwn(customAttributes, setCustom);
+      }
+      var jsAttributesHash = stringHashCode(stringify(customParams));
+      var aggregateHash = bucketHash + ':' + jsAttributesHash;
+      this.aggregator.store(type, aggregateHash, params, newMetrics, customParams);
+    }
+    function setCustom(key, val) {
+      customParams[key] = val && typeof val === 'object' ? 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];
+      mapOwn(globalCustomParams, setCustom);
+      mapOwn(interaction.root.attrs.custom, setCustom);
+      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 = stringHashCode(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' ? 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];
+      mapOwn(globalCustomParams, setCustom);
+      mapOwn(interaction.root.attrs.custom, setCustom);
+      mapOwn(localCustomParams, setCustom);
+      var params = item[2];
+      delete params._interactionId;
+      delete params._interactionNodeId;
+      var hash = item[1];
+      var jsAttributesHash = stringHashCode(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' ? stringify(val) : val;
+      }
+    });
+    delete this.errorCache[interaction.id];
+  }
+}

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

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export 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/esm/features/jserrors/aggregate/string-hash-code.test.js

@@ -0,0 +1,24 @@
+import { stringHashCode } from './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 = stringHashCode(input);
+  expect(result).toEqual(expected);
+});

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

@@ -0,0 +1,3 @@
+import { FEATURE_NAMES } from '../../loaders/features/features';
+export const FEATURE_NAME = FEATURE_NAMES.jserrors;
+export const NR_ERR_PROP = 'nr@seenError';

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

@@ -0,0 +1 @@
+export { Instrument as JSErrors } from './instrument/index';

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ee } from '../../../common/event-emitter/contextual-ee';
+import { mapOwn } from '../../../common/util/map-own';
+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) ee.on('internal-error', function (err) {
+  log(err.stack);
+});
+if (flags.dev) ee.on('fn-err', function (args, origThis, err) {
+  log(err.stack);
+});
+if (flags.dev) {
+  log('NR AGENT IN DEVELOPMENT MODE');
+  log('flags: ' + mapOwn(flags, function (key, val) {
+    return key;
+  }).join(', '));
+}
+function log(message) {
+  try {
+    if (flags.console) log(message);
+  } catch (err) {
+    // no op
+  }
+}