@newrelic/browser-agent 1.232.0 → 1.233.0

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

@@ -57,6 +57,7 @@
 // ex.message = ...
 // ex.name = ReferenceError
 import { formatStackTrace } from './format-stack-trace'
+import { canonicalizeUrl } from '../../../common/url/canonicalize-url'
 
 var debug = false
 
@@ -66,6 +67,23 @@ var gecko = /^\s*(?:(\S*|global code)(?:\(.*?\))?@)?((?:file|http|https|chrome|s
 var chrome_eval = /^\s*at .+ \(eval at \S+ \((?:(?:file|http|https):[^)]+)?\)(?:, [^:]*:\d+:\d+)?\)$/i
 var ie_eval = /^\s*at Function code \(Function code:\d+:\d+\)\s*/i
 
+/**
+ * Represents an error with a stack trace.
+ * @typedef {Object} StackInfo
+ * @property {string} name - The name of the error (e.g. 'TypeError').
+ * @property {string} message - The error message.
+ * @property {string} stackString - The stack trace as a string.
+ * @property {Array<Object>} frames - An array of frames in the stack trace.
+ * @property {string} frames.url - The URL of the file containing the code for the frame.
+ * @property {string} frames.func - The name of the function associated with the frame.
+ * @property {number} frames.line - The line number of the code in the frame.
+ */
+
+/**
+ * Attempts to compute a stack trace for the given exception.
+ * @param {Error} ex - The exception for which to compute the stack trace.
+ * @returns {StackInfo} A stack trace object containing information about the frames on the stack.
+ */
 export function computeStackTrace (ex) {
   var stack = null
 
@@ -110,9 +128,9 @@ export function computeStackTrace (ex) {
 }
 
 /**
- * Computes stack trace information from the stack property.
- * Chrome and Gecko use this property.
- * @param {Error} ex
+ * Computes stack trace information from the stack property. Chrome and Gecko use this property.
+ *
+ * @param {Error} ex - The error object to compute the stack trace for.
  * @return {?Object.<string, *>} Stack trace information.
  */
 function computeStackTraceFromStackProp (ex) {
@@ -136,22 +154,49 @@ function computeStackTraceFromStackProp (ex) {
   }
 }
 
+/**
+ * Parses a line from a JavaScript error stack trace and adds it to the given `info` object.
+ * Ignores all stack entries thrown from one of our wrapper functions.
+ *
+ * @param {object} info - The `info` object to add the parsed line to.
+ * @param {string} line - The line to parse.
+ * @returns {object} The `info` object with the parsed line added.
+ */
 function parseStackProp (info, line) {
-  var element = getElement(line)
+  let element = getStackElement(line)
 
+  // This catches lines that aren't frames (like the first line stating the error).
   if (!element) {
     info.stackLines.push(line)
     return info
   }
 
-  if (isWrapper(element.func)) info.wrapperSeen = true
-  else info.stackLines.push(line)
+  // Once we've seen a wrapper, ignore all subsequent stack entries.
+  if (isNrWrapper(element.func)) info.wrapperSeen = true
+  if (!info.wrapperSeen) {
+    // Query strings and fragments should be removed, and URLs matching the loader's origin should be "<inline>".
+    let canonicalUrl = canonicalizeUrl(element.url)
+    if (canonicalUrl !== element.url) {
+      line = line.replace(element.url, canonicalUrl)
+      element.url = canonicalUrl
+    }
+
+    info.stackLines.push(line)
+    info.frames.push(element)
+  }
 
-  if (!info.wrapperSeen) info.frames.push(element)
   return info
 }
 
-function getElement (line) {
+/**
+ * Parses a line from a JavaScript error stack trace to extract information about a stack trace element, such as the
+ * URL, function name, line number, and column number.
+ *
+ * @param {string} line - A single line from a JavaScript error stack trace.
+ * @returns {object} An object containing information about the stack trace element, including the URL, function
+ *     name, line number, and column number (if available).
+ */
+function getStackElement (line) {
   var parts = line.match(gecko)
   if (!parts) parts = line.match(chrome)
 
@@ -169,6 +214,14 @@ function getElement (line) {
   }
 }
 
+/**
+ * Computes a stack trace object from an error object, by extracting the source and line number from the error object,
+ * and using them to create a single stack frame.
+ *
+ * @param {Error} ex - The error object to compute the stack trace for.
+ * @returns {Object|null} - An object representing the computed stack trace, or null if the
+ * input error object does not contain a line number.
+ */
 function computeStackTraceBySourceAndLine (ex) {
   if (!('line' in ex)) return null
 
@@ -187,7 +240,10 @@ function computeStackTraceBySourceAndLine (ex) {
     })
   }
 
-  var stackString = className + ': ' + ex.message + '\n    at ' + ex.sourceURL
+  // Remove any query string and fragment
+  var canonicalUrl = canonicalizeUrl(ex.sourceURL)
+
+  var stackString = className + ': ' + ex.message + '\n    at ' + canonicalUrl
   if (ex.line) {
     stackString += ':' + ex.line
     if (ex.column) {
@@ -201,13 +257,19 @@ function computeStackTraceBySourceAndLine (ex) {
     message: ex.message,
     stackString: stackString,
     frames: [{
-      url: ex.sourceURL,
+      url: canonicalUrl,
       line: ex.line,
       column: ex.column
     }]
   })
 }
 
+/**
+ * For exceptions with no stack and only a message, derives a stack trace by extracting the class name and message.
+ *
+ * @param {Error} ex - The exception for which to compute the stack trace.
+ * @returns {StackTrace} A stack trace object containing the name and message of the exception.
+ */
 function computeStackTraceWithMessageOnly (ex) {
   var className = ex.name || getClassName(ex)
   if (!className) return null
@@ -221,11 +283,23 @@ function computeStackTraceWithMessageOnly (ex) {
   })
 }
 
+/**
+ * Attempts to extract the name of the constructor function (the class) of the given object.
+ *
+ * @param {Object} obj - The object for which to extract the constructor function name.
+ * @returns {string} The name of the constructor function, or 'unknown' if the name cannot be determined.
+ */
 function getClassName (obj) {
   var results = classNameRegex.exec(String(obj.constructor))
   return (results && results.length > 1) ? results[1] : 'unknown'
 }
 
-function isWrapper (functionName) {
+/**
+ * Checks whether the given function name is a New Relic wrapper function.
+ *
+ * @param {string} functionName - The name of the function to check.
+ * @returns {boolean} True if the function name includes the string 'nrWrapper', false otherwise.
+ */
+function isNrWrapper (functionName) {
   return (functionName && functionName.indexOf('nrWrapper') >= 0)
 }

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

@@ -1,16 +1,34 @@
 import { faker } from '@faker-js/faker'
 import { browserErrorUtils } from '../../../../tools/testing-utils'
-import { computeStackTrace } from './compute-stack-trace'
+
+const globalScopeLocation = 'https://example.com/'
+
+const mockGlobalScopeLocation = (url) => {
+  jest.doMock('../../../common/util/global-scope', () => ({
+    initialLocation: url || globalScopeLocation
+  }))
+}
+
+afterEach(() => {
+  jest.resetModules()
+  jest.clearAllMocks()
+})
 
 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)'
+  stack:
+    'RangeError: Invalid array length\n' +
+    '    at errorTest (' + globalScopeLocation + '?loader=spa#hello:74:16)\n' +
+    '    at captureError (' + globalScopeLocation + 'js/script.js?loader=spa:17:9)\n' +
+    '    at onload (' + globalScopeLocation + 'js/script.js?loader=spa:70:5)'
 }
 
-test('parsing should return a failure for a null error object', () => {
+test('parsing should return a failure for a null error object', async () => {
+  mockGlobalScopeLocation()
+  const { computeStackTrace } = await import('./compute-stack-trace')
   const result = computeStackTrace(null)
 
   expect(result).toEqual(expect.objectContaining({
@@ -21,29 +39,49 @@ test('parsing should return a failure for a null error object', () => {
 })
 
 describe('errors with stack property', () => {
-  test('parsed name should be unknown when name and constructor are missing', () => {
+  test('should show <inline> for same-page stack string URLs but not sub-paths', async () => {
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError
+    })
+
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
+    const result = computeStackTrace(mockError)
+
+    expect(result).toEqual(expect.objectContaining({
+      stackString: // canonicalized
+        'RangeError: Invalid array length\n' +
+        '    at errorTest (<inline>:74:16)\n' +
+        '    at captureError (' + globalScopeLocation + 'js/script.js:17:9)\n' +
+        '    at onload (' + globalScopeLocation + 'js/script.js:70:5)'
+    }))
+  })
+
+  test('parsed name should be unknown when name and constructor are missing', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
       name: null,
       constructor: null
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
-      name: 'unknown',
-      message: mockError.message,
-      stackString: mockError.stack
+      name: 'unknown'
     }))
   })
 
-  test('parsed stack should not contain nrWrapper', () => {
+  test('parsed stack should not contain nrWrapper', async () => {
     const alteredError = baseMockError
     alteredError.stack +=
-      '\n    at nrWrapper (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html?loader=spa:60:17)'
+      '\n    at nrWrapper (' + globalScopeLocation + '?loader=spa:60:17)'
     const mockError = browserErrorUtils.constructError(alteredError)
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
@@ -57,20 +95,31 @@ describe('errors with stack property', () => {
     }))
   })
 
-  test('stack should still parse when column numbers are missing', () => {
+  test('stack should still parse when column numbers are missing', async () => {
     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)'
+      'RangeError: Invalid array length\n' +
+      'Error: Blocked a frame with origin "http://bam-test-1.nr-local.net:3334" from accessing a cross-origin frame.\n' +
+      '    at errorTest (' + globalScopeLocation + '?loader=spa:60)\n' +
+      '    at captureError (' + globalScopeLocation + '?loader=spa:17)\n' +
+      '    at onload (' + globalScopeLocation + '?loader=spa:57)'
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
       mode: 'stack',
       name: mockError.name,
       message: mockError.message,
-      stackString: mockError.stack
+      stackString:
+        'RangeError: Invalid array length\n' +
+        'Error: Blocked a frame with origin "http://bam-test-1.nr-local.net:3334" from accessing a cross-origin frame.\n' +
+        '    at errorTest (<inline>:60)\n' +
+        '    at captureError (<inline>:17)\n' +
+        '    at onload (<inline>:57)'
     }))
     expect(result.frames.length).toEqual(3)
     expect(result.frames).toContainEqual(expect.objectContaining({
@@ -87,13 +136,15 @@ describe('errors with stack property', () => {
     }))
   })
 
-  test('parser can handle chrome eval stack', () => {
+  test('parser can handle chrome eval stack', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
       stack:
-        '    at foobar (eval at foobar (http://bam-test-1.nr-local.net:3334/tests/assets/instrumented.html))'
+        '    at foobar (eval at foobar (' + globalScopeLocation + '))'
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
@@ -108,7 +159,7 @@ describe('errors with stack property', () => {
     }))
   })
 
-  test('parser can handle ie eval stack', () => {
+  test('parser can handle ie eval stack', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: 'TypeError: Permission denied',
       name: 'TypeError',
@@ -118,6 +169,8 @@ describe('errors with stack property', () => {
         '    at Function code (Function code:23:23)'
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
@@ -132,13 +185,15 @@ describe('errors with stack property', () => {
     }))
   })
 
-  test('parser can handle stack with anonymous function', () => {
+  test('parser can handle stack with anonymous function', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
       stack:
         'anonymous'
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
@@ -158,7 +213,7 @@ 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', () => {
+  test('parsed stack should contain sourceURL and line number', async () => {
     const sourceURL = faker.internet.url()
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
@@ -167,6 +222,8 @@ describe('errors without stack property and with line property', () => {
       sourceURL
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
@@ -185,7 +242,7 @@ 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, line number, and column number', () => {
+  test('parsed stack should contain sourceURL, line number, and column number', async () => {
     const sourceURL = faker.internet.url()
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
@@ -195,6 +252,8 @@ describe('errors without stack property and with line property', () => {
       sourceURL
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
@@ -211,7 +270,7 @@ describe('errors without stack property and with line property', () => {
     }))
   })
 
-  test('parsed stack should contain "evaluated code" if sourceURL property is not present', () => {
+  test('parsed stack should contain "evaluated code" if sourceURL property is not present', async () => {
     const mockError = browserErrorUtils.constructError({
       ...baseMockError,
       line: 100,
@@ -219,6 +278,8 @@ describe('errors without stack property and with line property', () => {
       stack: undefined
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
@@ -233,6 +294,58 @@ describe('errors without stack property and with line property', () => {
     }))
   })
 
+  /**
+   * @deprecated sourceURL is no longer present in errors for any browsers we support
+   */
+  test('should show <inline> for same-page URLs', async () => {
+    const pageLocation = faker.internet.url()
+    const sourceURL = pageLocation + '?abc=123'
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError,
+      line: 100,
+      column: 200,
+      stack: undefined,
+      sourceURL: sourceURL
+    })
+
+    mockGlobalScopeLocation(pageLocation)
+    const { computeStackTrace } = await import('./compute-stack-trace')
+    const result = computeStackTrace(mockError)
+
+    expect(result).toEqual(expect.objectContaining({
+      stackString: `${mockError.name}: ${mockError.message}\n    at <inline>:${mockError.line}:${mockError.column}`
+    }))
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      url: '<inline>'
+    }))
+  })
+
+  /**
+   * @deprecated sourceURL is no longer present in errors for any browsers we support
+   */
+  test('should NOT show <inline> for same-domain URLs with a sub-path', async () => {
+    const pageLocation = faker.internet.url()
+    const sourceURL = pageLocation + '/path/to/script.js'
+    const mockError = browserErrorUtils.constructError({
+      ...baseMockError,
+      line: 100,
+      column: 200,
+      stack: undefined,
+      sourceURL
+    })
+
+    mockGlobalScopeLocation(pageLocation)
+    const { computeStackTrace } = await import('./compute-stack-trace')
+    const result = computeStackTrace(mockError)
+
+    expect(result).toEqual(expect.objectContaining({
+      stackString: `${mockError.name}: ${mockError.message}\n    at ${sourceURL}:${mockError.line}:${mockError.column}`
+    }))
+    expect(result.frames).toContainEqual(expect.objectContaining({
+      url: sourceURL
+    }))
+  })
+
   // TODO: computeStackTraceBySourceAndLine does not respect firefox lineNumber and columnNumber properties when stack is empty
 })
 
@@ -241,12 +354,14 @@ describe('errors without stack property and with line property', () => {
  * error, including primitives.
  */
 describe('errors that are messages only or primitives', () => {
-  test('parser should get error name from constructor', () => {
+  test('parser should get error name from constructor', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: '0',
       constructor: 'function Number() { [native code] }'
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
@@ -257,13 +372,15 @@ describe('errors that are messages only or primitives', () => {
     }))
   })
 
-  test('parser should get error name from name property', () => {
+  test('parser should get error name from name property', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: '0',
       name: faker.datatype.uuid(),
       constructor: 'function Number() { [native code] }'
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
@@ -274,7 +391,7 @@ describe('errors that are messages only or primitives', () => {
     }))
   })
 
-  test('parser should include the message property', () => {
+  test('parser should include the message property', async () => {
     const mockError = browserErrorUtils.constructError({
       toString: '0',
       name: faker.datatype.uuid(),
@@ -282,6 +399,8 @@ describe('errors that are messages only or primitives', () => {
       constructor: 'function Number() { [native code] }'
     })
 
+    mockGlobalScopeLocation()
+    const { computeStackTrace } = await import('./compute-stack-trace')
     const result = computeStackTrace(mockError)
 
     expect(result).toEqual(expect.objectContaining({
@@ -293,5 +412,3 @@ describe('errors that are messages only or primitives', () => {
     }))
   })
 })
-
-// describe('')

package/src/features/jserrors/aggregate/index.js

@@ -4,7 +4,6 @@
  */
 
 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'
@@ -21,9 +20,13 @@ import { globalScope } from '../../../common/util/global-scope'
 import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { FeatureBase } from '../../utils/feature-base'
+import { AggregateBase } from '../../utils/aggregate-base'
 
-export class Aggregate extends FeatureBase {
+/**
+ * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
+ */
+
+export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
@@ -105,56 +108,27 @@ export class Aggregate extends FeatureBase {
     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 = ''
+  /**
+   * Builds a standardized stack trace string from the frames in the given `stackInfo` object, with each frame separated
+   * by a newline character. Lines take the form `<functionName>@<url>:<lineNumber>`.
+   *
+   * @param {StackInfo} stackInfo - An object specifying a stack string and individual frames.
+   * @returns {string} A canonical stack string built from the URLs and function names in the given `stackInfo` object.
+   */
+  buildCanonicalStackString (stackInfo) {
+    var canonicalStackString = ''
 
     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)
-      }
+      if (canonicalStackString) canonicalStackString += '\n'
+      if (func) canonicalStackString += func + '@'
+      if (typeof frame.url === 'string') canonicalStackString += frame.url
+      if (frame.line) canonicalStackString += ':' + frame.line
     }
 
-    return stackInfo
+    return canonicalStackString
   }
 
   storeError (err, time, internal, customAttributes) {
@@ -173,11 +147,11 @@ export class Aggregate extends FeatureBase {
       // Again as with previous usage, all falsey values would include the error.
     }
 
-    var stackInfo = this.canonicalizeStackURLs(computeStackTrace(err))
-    var canonicalStack = this.buildCanonicalStackString(stackInfo)
+    var stackInfo = computeStackTrace(err)
+    var canonicalStackString = this.buildCanonicalStackString(stackInfo)
 
     const params = {
-      stackHash: stringHashCode(canonicalStack),
+      stackHash: stringHashCode(canonicalStackString),
       exceptionClass: stackInfo.name,
       request_uri: globalScope?.location.pathname
     }
@@ -215,10 +189,12 @@ export class Aggregate extends FeatureBase {
     var type = internal ? 'ierr' : 'err'
     var newMetrics = { time: time }
 
-    // stn and spa aggregators listen to this event - stn sends the error in its payload,
+    // sr, 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)
+    const msg = [type, bucketHash, params, newMetrics]
+    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionTrace, this.ee)
+    handle('errorAgg', msg, undefined, FEATURE_NAMES.spa, this.ee)
+    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionReplay, this.ee)
 
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return

package/src/features/jserrors/instrument/index.js

@@ -7,7 +7,6 @@ import { handle } from '../../../common/event-emitter/handle'
 import { now } from '../../../common/timing/now'
 import { getOrSet } from '../../../common/util/get-or-set'
 import { wrapRaf, wrapTimer, wrapEvents, wrapXhr } from '../../../common/wrap'
-import slice from 'lodash._slice'
 import './debug'
 import { InstrumentBase } from '../../utils/instrument-base'
 import { FEATURE_NAME, NR_ERR_PROP } from '../constants'