@newrelic/browser-agent 0.0.9 → 0.1.230

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

@@ -0,0 +1,231 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/* eslint-disable no-useless-escape */
+
+// computeStackTrace: cross-browser stack traces in JavaScript
+//
+// Syntax:
+//   s = computeStackTrace(exception) // consider using TraceKit.report instead
+// Returns:
+//   s.name              - exception name
+//   s.message           - exception message
+//   s.stack[i].url      - JavaScript or HTML file URL
+//   s.stack[i].func     - function name, or empty for anonymous functions
+//   s.stack[i].line     - line number, if known
+//   s.stack[i].column   - column number, if known
+//   s.stack[i].context  - an array of source code lines; the middle element corresponds to the correct line#
+//   s.mode              - 'stack', 'stacktrace', 'multiline', 'callers', 'onerror', or 'failed' -- method used to collect the stack trace
+//
+// Supports:
+//   - Firefox:  full stack trace with line numbers and unreliable column
+//               number on top frame
+//   - Chrome:   full stack trace with line and column numbers
+//   - Safari:   line and column number for the topmost stacktrace element
+//               only
+//   - IE:       no line numbers whatsoever
+
+// Contents of Exception in various browsers.
+//
+// SAFARI:
+// ex.message = Can't find variable: qq
+// ex.line = 59
+// ex.sourceId = 580238192
+// ex.sourceURL = http://...
+// ex.expressionBeginOffset = 96
+// ex.expressionCaretOffset = 98
+// ex.expressionEndOffset = 98
+// ex.name = ReferenceError
+//
+// FIREFOX:
+// ex.message = qq is not defined
+// ex.fileName = http://...
+// ex.lineNumber = 59
+// ex.stack = ...stack trace... (see the example below)
+// ex.name = ReferenceError
+//
+// CHROME:
+// ex.message = qq is not defined
+// ex.name = ReferenceError
+// ex.type = not_defined
+// ex.arguments = ['aa']
+// ex.stack = ...stack trace...
+//
+// INTERNET EXPLORER:
+// ex.message = ...
+// ex.name = ReferenceError
+import { formatStackTrace } from './format-stack-trace'
+
+var debug = false
+
+var classNameRegex = /function (.+?)\s*\(/
+var chrome = /^\s*at (?:((?:\[object object\])?(?:[^(]*\([^)]*\))*[^()]*(?: \[as \S+\])?) )?\(?((?:file|http|https|chrome-extension):.*?)?:(\d+)(?::(\d+))?\)?\s*$/i
+var gecko = /^\s*(?:(\S*|global code)(?:\(.*?\))?@)?((?:file|http|https|chrome|safari-extension).*?):(\d+)(?::(\d+))?\s*$/i
+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
+
+export function computeStackTrace (ex) {
+  var stack = null
+
+  try {
+    stack = computeStackTraceFromStackProp(ex)
+    if (stack) {
+      return stack
+    }
+  } catch (e) {
+    if (debug) {
+      throw e
+    }
+  }
+
+  try {
+    stack = computeStackTraceBySourceAndLine(ex)
+    if (stack) {
+      return stack
+    }
+  } catch (e) {
+    if (debug) {
+      throw e
+    }
+  }
+
+  try {
+    stack = computeStackTraceWithMessageOnly(ex)
+    if (stack) {
+      return stack
+    }
+  } catch (e) {
+    if (debug) {
+      throw e
+    }
+  }
+
+  return {
+    mode: 'failed',
+    stackString: '',
+    frames: []
+  }
+}
+
+/**
+ * Computes stack trace information from the stack property.
+ * Chrome and Gecko use this property.
+ * @param {Error} ex
+ * @return {?Object.<string, *>} Stack trace information.
+ */
+function computeStackTraceFromStackProp (ex) {
+  if (!ex.stack) {
+    return null
+  }
+
+  var errorInfo = ex.stack.split('\n').reduce(
+    parseStackProp,
+    { frames: [], stackLines: [], wrapperSeen: false }
+  )
+
+  if (!errorInfo.frames.length) return null
+
+  return {
+    mode: 'stack',
+    name: ex.name || getClassName(ex),
+    message: ex.message,
+    stackString: formatStackTrace(errorInfo.stackLines),
+    frames: errorInfo.frames
+  }
+}
+
+function parseStackProp (info, line) {
+  var element = getElement(line)
+
+  if (!element) {
+    info.stackLines.push(line)
+    return info
+  }
+
+  if (isWrapper(element.func)) info.wrapperSeen = true
+  else info.stackLines.push(line)
+
+  if (!info.wrapperSeen) info.frames.push(element)
+  return info
+}
+
+function getElement (line) {
+  var parts = line.match(gecko)
+  if (!parts) parts = line.match(chrome)
+
+  if (parts) {
+    return ({
+      url: parts[2],
+      func: (parts[1] !== 'Anonymous function' && parts[1] !== 'global code' && parts[1]) || null,
+      line: +parts[3],
+      column: parts[4] ? +parts[4] : null
+    })
+  }
+
+  if (line.match(chrome_eval) || line.match(ie_eval) || line === 'anonymous') {
+    return { func: 'evaluated code' }
+  }
+}
+
+function computeStackTraceBySourceAndLine (ex) {
+  if (!('line' in ex)) return null
+
+  var className = ex.name || getClassName(ex)
+
+  // Safari does not provide a URL for errors in eval'd code
+  if (!ex.sourceURL) {
+    return ({
+      mode: 'sourceline',
+      name: className,
+      message: ex.message,
+      stackString: getClassName(ex) + ': ' + ex.message + '\n    in evaluated code',
+      frames: [{
+        func: 'evaluated code'
+      }]
+    })
+  }
+
+  var stackString = className + ': ' + ex.message + '\n    at ' + ex.sourceURL
+  if (ex.line) {
+    stackString += ':' + ex.line
+    if (ex.column) {
+      stackString += ':' + ex.column
+    }
+  }
+
+  return ({
+    mode: 'sourceline',
+    name: className,
+    message: ex.message,
+    stackString: stackString,
+    frames: [{
+      url: ex.sourceURL,
+      line: ex.line,
+      column: ex.column
+    }]
+  })
+}
+
+function computeStackTraceWithMessageOnly (ex) {
+  var className = ex.name || getClassName(ex)
+  if (!className) return null
+
+  return ({
+    mode: 'nameonly',
+    name: className,
+    message: ex.message,
+    stackString: className + ': ' + ex.message,
+    frames: []
+  })
+}
+
+function getClassName (obj) {
+  var results = classNameRegex.exec(String(obj.constructor))
+  return (results && results.length > 1) ? results[1] : 'unknown'
+}
+
+function isWrapper (functionName) {
+  return (functionName && functionName.indexOf('nrWrapper') >= 0)
+}

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))
+  })
+})