@newrelic/browser-agent 0.1.229 → 0.1.231

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

@@ -0,0 +1,297 @@
+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/src/features/jserrors/aggregate/format-stack-trace.js

@@ -0,0 +1,30 @@
+/*
+ * 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/src/features/jserrors/aggregate/format-stack-trace.test.js

@@ -0,0 +1,39 @@
+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/src/features/jserrors/aggregate/index.js

@@ -0,0 +1,310 @@
+/*
+ * 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'
+
+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()
+    const agentRuntime = 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(computeStackTrace(err))
+    var canonicalStack = this.buildCanonicalStackString(stackInfo)
+
+    const params = {
+      stackHash: stringHashCode(canonicalStack),
+      exceptionClass: stackInfo.name,
+      request_uri: 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 = 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(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
+    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/src/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
+}