rollbar 2.24.1 → 2.25.0

package/index.d.ts

@@ -40,6 +40,9 @@ declare namespace Rollbar {
     ) => void | Promise<TResult>;
     export type MaybeError = Error | undefined | null;
     export type Level = "debug" | "info" | "warning" | "error" | "critical";
+    /**
+     * {@link https://docs.rollbar.com/docs/rollbarjs-configuration-reference#reference}
+     */
     export interface Configuration {
         accessToken?: string;
         addErrorContext?: boolean;
@@ -52,7 +55,15 @@ declare namespace Rollbar {
         captureUnhandledRejections?: boolean;
         captureUsername?: boolean;
         checkIgnore?: (isUncaught: boolean, args: LogArgument[], item: object) => boolean;
+        /**
+         * `codeVersion` takes precedence over `code_version`, if provided.
+         * `client.javascript.code_version` takes precedence over both top level properties.
+         */
         codeVersion?: string;
+        /**
+         * `codeVersion` takes precedence over `code_version`, if provided.
+         * `client.javascript.code_version` takes precedence over both top level properties.
+         */
         code_version?: string;
         enabled?: boolean;
         endpoint?: string;
@@ -77,7 +88,7 @@ declare namespace Rollbar {
         nodeSourceMaps?: boolean;
         onSendCallback?: (isUncaught: boolean, args: LogArgument[], item: object) => void;
         overwriteScrubFields?: boolean;
-        payload?: object;
+        payload?: Payload;
         reportLevel?: Level;
         rewriteFilenamePatterns?: string[];
         scrubFields?: string[];
@@ -89,7 +100,7 @@ declare namespace Rollbar {
         stackTraceLimit?: number;
         telemetryScrubber?: TelemetryScrubber;
         timeout?: number;
-        transform?: (data: object, item: object) => void;
+        transform?: (data: object, item: object) => void | Promise<void>;
         transmit?: boolean;
         uncaughtErrorLevel?: Level;
         verbose?: boolean;
@@ -143,7 +154,7 @@ declare namespace Rollbar {
     export type LocalsType = typeof Locals;
     export type LocalsOptions = LocalsType | LocalsSettings;
     export interface LocalsSettings {
-        locals: LocalsType,
+        module: LocalsType,
         enabled?: boolean;
         uncaughtOnly?: boolean;
         depth?: number;
@@ -169,4 +180,73 @@ declare namespace Rollbar {
         scrub?: ScrubType,
         truncation?: TruncationType
     }
+
+    /**
+      * @deprecated number is deprecated for this field
+      */
+     export type DeprecatedNumber = number;
+
+    /**
+     * {@link https://docs.rollbar.com/docs/rollbarjs-configuration-reference#payload-1}
+     */
+    export interface Payload {
+        person?: {
+            id: string | DeprecatedNumber;
+            username?: string;
+            email?: string;
+            [property: string]: any;
+        },
+        context?: any;
+        client?: {
+            javascript?: {
+                /**
+                 * Version control number (i.e. git SHA) of the current revision. Used for linking filenames in stacktraces to GitHub.
+                 * Note: for the purposes of nesting under the payload key, only code_version will correctly set the value in the final item.
+                 * However, if you wish to set this code version at the top level of the configuration object rather than nested under
+                 * the payload key, we will accept both codeVersion and code_version with codeVersion given preference if both happened
+                 * to be defined. Furthermore, if code_version is nested under the payload key this will have the final preference over
+                 * any value set at the top level.
+                 */
+                code_version?: string | DeprecatedNumber;
+                /**
+                 * When true, the Rollbar service will attempt to find and apply source maps to all frames in the stack trace.
+                 * @default false
+                 */
+                source_map_enabled?: boolean;
+                /**
+                 * When true, the Rollbar service will attempt to apply source maps to frames even if they are missing column numbers.
+                 * Works best when the minified javascript file is generated using newlines instead of semicolons.
+                 * @default false
+                 */
+                guess_uncaught_frames?: boolean;
+                [property: string]: any;
+            }
+            [property: string]: any;
+        },
+        /**
+         * The environment that your code is running in.
+         * @default undefined
+         */
+        environment?: string;
+        server?: {
+            /**
+             * @default master
+             */
+            branch?: string;
+            /**
+             * The hostname of the machine that rendered the page.
+             */
+            host?: string;
+            /**
+             * It is used in two different ways: `source maps`, and `source control`.
+             *
+             * If you are looking for more information on it please go to:
+             * {@link https://docs.rollbar.com/docs/source-maps}
+             * {@link https://docs.rollbar.com/docs/source-control}
+             */
+            root?: string;
+            [property: string]: any;
+        },
+        [property: string]: any;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollbar",
-  "version": "2.24.1",
+  "version": "2.25.0",
   "repository": {
     "type": "git",
     "url": "http://github.com/rollbar/rollbar.js"
@@ -11,14 +11,13 @@
   "browser": "dist/rollbar.umd.min.js",
   "types": "./index.d.ts",
   "dependencies": {
-    "async": "~1.2.1",
+    "async": "~3.2.3",
     "console-polyfill": "0.3.0",
     "error-stack-parser": "^2.0.4",
     "json-stringify-safe": "~5.0.0",
     "lru-cache": "~2.2.1",
     "request-ip": "~2.0.1",
-    "source-map": "^0.5.7",
-    "uuid": "3.0.x"
+    "source-map": "^0.5.7"
   },
   "devDependencies": {
     "babel-core": "^6.26.3",

package/src/browser/telemetry.js

@@ -403,8 +403,10 @@ Instrumenter.prototype.instrumentNetwork = function() {
               // Test to ensure body is a Promise, which it should always be.
               if (typeof body.then === 'function') {
                 body.then(function (text) {
-                  if (self.isJsonContentType(metadata.response_content_type)) {
+                  if (text && self.isJsonContentType(metadata.response_content_type)) {
                     metadata.response.body = self.scrubJson(text);
+                  } else {
+                    metadata.response.body = text;
                   }
                 });
               } else {
@@ -729,16 +731,16 @@ Instrumenter.prototype.handleCspError = function(message) {
 }
 
 Instrumenter.prototype.deinstrumentContentSecurityPolicy = function() {
-  if (!('addEventListener' in this._window)) { return; }
+  if (!('addEventListener' in this._document)) { return; }
 
   this.removeListeners('contentsecuritypolicy');
 };
 
 Instrumenter.prototype.instrumentContentSecurityPolicy = function() {
-  if (!('addEventListener' in this._window)) { return; }
+  if (!('addEventListener' in this._document)) { return; }
 
   var cspHandler = this.handleCspEvent.bind(this);
-  this.addListener('contentsecuritypolicy', this._window, 'securitypolicyviolation', null, cspHandler, false);
+  this.addListener('contentsecuritypolicy', this._document, 'securitypolicyviolation', null, cspHandler, false);
 };
 
 Instrumenter.prototype.addListener = function(section, obj, type, altType, handler, capture) {

package/src/browser/transforms.js

@@ -42,8 +42,8 @@ function addErrorContext(item) {
 
   chain.push(err);
 
-  while (err.nested) {
-    err = err.nested;
+  while (err.nested || err.cause) {
+    err = err.nested || err.cause;
     chain.push(err);
   }
 

package/src/defaults.js

@@ -1,5 +1,5 @@
 module.exports = {
-  version: '2.24.1',
+  version: '2.25.0',
   endpoint: 'api.rollbar.com/api/1/item/',
   logLevel: 'debug',
   reportLevel: 'debug',

package/src/errorParser.js

@@ -64,11 +64,11 @@ function Stack(exception, skip) {
 function parse(e, skip) {
   var err = e;
 
-  if (err.nested) {
+  if (err.nested || err.cause) {
     var traceChain = [];
     while (err) {
       traceChain.push(new Stack(err, skip));
-      err = err.nested;
+      err = err.nested || err.cause;
 
       skip = 0; // Only apply skip value to primary error
     }

package/src/server/parser.js

@@ -181,7 +181,7 @@ function shouldReadFrameFile(frameFilename, callback) {
   isCached = !!cache.get(frameFilename);
   isPending = !!pendingReads[frameFilename];
 
-  callback(isValidFilename && !isCached && !isPending);
+  callback(null, isValidFilename && !isCached && !isPending);
 }
 
 
@@ -201,19 +201,13 @@ function readFileLines(filename, callback) {
   }
 }
 
-
-/* Older versions of node do not have fs.exists so we implement our own */
 function checkFileExists(filename, callback) {
   if (stackTrace.sourceContent(filename)) {
-    return callback(true);
-  }
-  if (fs.exists !== undefined) {
-    fs.exists(filename, callback);
-  } else {
-    fs.stat(filename, function (err) {
-      callback(!err);
-    });
+    return callback(null, true);
   }
+  fs.stat(filename, function (err) {
+    callback(null, !err);
+  });
 }
 
 
@@ -226,7 +220,9 @@ function gatherContexts(frames, callback) {
     }
   });
 
-  async.filter(frameFilenames, shouldReadFrameFile, function (results) {
+  async.filter(frameFilenames, shouldReadFrameFile, function (err, results) {
+    if (err) return callback(err);
+
     var tempFileCache;
 
     tempFileCache = {};
@@ -270,7 +266,8 @@ function gatherContexts(frames, callback) {
       callback(null);
     }
 
-    async.filter(results, checkFileExists, function (filenames) {
+    async.filter(results, checkFileExists, function (err, filenames) {
+      if (err) return callback(err);
       async.each(filenames, gatherFileData, function (err) {
         if (err) {
           return callback(err);
@@ -367,7 +364,8 @@ exports.parseStack = function (stack, options, item, callback) {
       return callback(err);
     }
     frames.reverse();
-    async.filter(frames, function (frame, callback) { callback(!!frame); }, function (results) {
+    async.filter(frames, function (frame, callback) { callback(null, !!frame); }, function (err, results) {
+      if (err) return callback(err);
       gatherContexts(results, callback);
     });
   });

package/src/server/transforms.js

@@ -85,7 +85,7 @@ function handleItemWithError(item, options, callback) {
   var chain = [];
   do {
     errors.push(err);
-    err = err.nested;
+    err = err.nested || err.cause;
   } while (err);
   item.stackInfo = chain;
 

package/test/browser.transforms.test.js

@@ -30,6 +30,10 @@ function itemFromArgs(args) {
   return item;
 }
 
+function chromeMajorVersion() {
+  return parseInt(navigator.userAgent.match(/Chrome\/([0-9]+)\./)[1]);
+}
+
 describe('handleDomException', function() {
   it('should do nothing if not a DOMException', function(done) {
     var err = new Error('test');
@@ -452,6 +456,45 @@ describe('addBody', function() {
       });
     });
   });
+  describe('with error cause', function() {
+    // Error cause was introduced in Chrome 93.
+    if (chromeMajorVersion() < 93) return;
+
+    it('should create trace_chain', function(done) {
+      var causeErr = new Error('cause error');
+      var err = new Error('test error', { cause: causeErr});
+      var args = ['a message', err];
+      var item = itemFromArgs(args);
+      var options = {};
+      t.handleItemWithError(item, options, function(e, i) {
+        expect(i.stackInfo).to.be.ok();
+      });
+      t.addBody(item, options, function(e, i) {
+        expect(i.data.body.trace_chain.length).to.eql(2);
+        expect(i.data.body.trace_chain[0].exception.message).to.eql('test error');
+        expect(i.data.body.trace_chain[1].exception.message).to.eql('cause error');
+        done(e);
+      });
+    });
+    it('should create add error context as custom data', function(done) {
+      var causeErr = new Error('cause error');
+      causeErr.rollbarContext = { err1: 'cause context' };
+      var err = new Error('test error', { cause: causeErr});
+      err.rollbarContext = { err2: 'error context' };
+      var args = ['a message', err];
+      var item = itemFromArgs(args);
+      var options = { addErrorContext: true };
+      t.handleItemWithError(item, options, function(e, i) {
+        expect(i.stackInfo).to.be.ok();
+      });
+      t.addBody(item, options, function(e, i) {
+        expect(i.data.body.trace_chain.length).to.eql(2);
+        expect(i.data.custom.err1).to.eql('cause context');
+        expect(i.data.custom.err2).to.eql('error context');
+        done(e);
+      });
+    });
+  });
 });
 
 describe('scrubPayload', function() {

package/test/server.transforms.test.js

@@ -30,6 +30,22 @@ async function throwInScriptFile(rollbar, filepath, callback) {
   callback(rollbar);
 }
 
+var nodeVersion = function () {
+  var version = process.versions.node.split('.');
+
+  return [
+    parseInt(version[0]),
+    parseInt(version[1]),
+    parseInt(version[2]),
+  ];
+}();
+
+var isMinNodeVersion = function(major, minor) {
+  return (
+    nodeVersion[0] > major || (nodeVersion[0] === major && nodeVersion[1] >= minor)
+  );
+}
+
 vows.describe('transforms')
   .addBatch({
     'baseData': {
@@ -494,7 +510,42 @@ vows.describe('transforms')
                 assert.equal(item.data.custom.err1, 'nested context');
                 assert.equal(item.data.custom.err2, 'error context');
               }
-            }
+            },
+            'with an error cause': {
+              topic: function (options) {
+                var test = function() {
+                  var x = thisVariableIsNotDefined;
+                };
+                var err;
+                try {
+                  test();
+                } catch (e) {
+                  err = new Error('cause message', { cause: e });
+                  e.rollbarContext = { err1: 'cause context' };
+                  err.rollbarContext = { err2: 'error context' };
+                }
+                var item = {
+                  data: {body: {}},
+                  err: err
+                };
+                t.handleItemWithError(item, options, this.callback);
+              },
+              'should not error': function(err, item) {
+                assert.ifError(err);
+              },
+              'should have the right data in the trace_chain': function(err, item) {
+                // Error cause was introduced in Node 16.9.
+                if (!isMinNodeVersion(16, 9)) return;
+
+                var trace_chain = item.stackInfo;
+                assert.lengthOf(trace_chain, 2);
+                assert.equal(trace_chain[0].exception.class, 'Error');
+                assert.equal(trace_chain[0].exception.message, 'cause message');
+                assert.equal(trace_chain[1].exception.class, 'ReferenceError');
+                assert.equal(item.data.custom.err1, 'cause context');
+                assert.equal(item.data.custom.err2, 'error context');
+              }
+            },
           }
         }
       }