@newrelic/browser-agent 0.0.9 → 0.1.230

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

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeStackTrace = computeStackTrace;
+var _formatStackTrace = require("./format-stack-trace");
+/*
+ * 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
+
+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;
+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: (0, _formatStackTrace.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/dist/cjs/features/jserrors/aggregate/compute-stack-trace.test.js

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

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

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

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

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