rollbar 2.26.2 → 2.26.4

package/test/predicates.test.js

@@ -5,490 +5,536 @@
 
 var p = require('../src/predicates');
 var logger = {
-  log: function() {},
-  error: function() {}
+  log: function () {},
+  error: function () {},
 };
 
-describe('userCheckIgnore', function() {
-  it('should return true if no user function', function() {
-    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
-    var settings = {reportLevel: 'debug'};
+describe('userCheckIgnore', function () {
+  it('should return true if no user function', function () {
+    var item = { level: 'debug', body: 'stuff', _originalArgs: [1, 2, 3] };
+    var settings = { reportLevel: 'debug' };
     expect(p.userCheckIgnore(logger)(item, settings)).to.be.ok();
   });
-  it('should return true if checkIgnore is not a function', function() {
-    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
-    var settings = {reportLevel: 'debug', checkIgnore: true};
+  it('should return true if checkIgnore is not a function', function () {
+    var item = { level: 'debug', body: 'stuff', _originalArgs: [1, 2, 3] };
+    var settings = { reportLevel: 'debug', checkIgnore: true };
     expect(p.userCheckIgnore(logger)(item, settings)).to.be.ok();
   });
-  it('should return true if checkIgnore returns false', function() {
-    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
-    var settings = {reportLevel: 'debug', checkIgnore: function() {
-      return false;
-    }};
+  it('should return true if checkIgnore returns false', function () {
+    var item = { level: 'debug', body: 'stuff', _originalArgs: [1, 2, 3] };
+    var settings = {
+      reportLevel: 'debug',
+      checkIgnore: function () {
+        return false;
+      },
+    };
     expect(p.userCheckIgnore(logger)(item, settings)).to.be.ok();
   });
-  it('should return false if checkIgnore returns true', function() {
-    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
-    var settings = {reportLevel: 'debug', checkIgnore: function() {
-      return true;
-    }};
+  it('should return false if checkIgnore returns true', function () {
+    var item = { level: 'debug', body: 'stuff', _originalArgs: [1, 2, 3] };
+    var settings = {
+      reportLevel: 'debug',
+      checkIgnore: function () {
+        return true;
+      },
+    };
     expect(p.userCheckIgnore(logger)(item, settings)).to.not.be.ok();
   });
-  it('should return true if checkIgnore throws', function() {
-    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
-    var settings = {reportLevel: 'debug', checkIgnore: function() {
-      throw new Error('bork bork');
-    }};
+  it('should return true if checkIgnore throws', function () {
+    var item = { level: 'debug', body: 'stuff', _originalArgs: [1, 2, 3] };
+    var settings = {
+      reportLevel: 'debug',
+      checkIgnore: function () {
+        throw new Error('bork bork');
+      },
+    };
     expect(p.userCheckIgnore(logger)(item, settings)).to.be.ok();
     expect(settings.checkIgnore).to.not.be.ok();
   });
-  it('should get the right arguments', function() {
-    var item = {level: 'debug', body: 'stuff', _originalArgs: [1,2,3]};
-    var settings = {reportLevel: 'debug', checkIgnore: function(isUncaught, args, payload) {
-      expect(isUncaught).to.not.be.ok();
-      expect(args).to.eql([1,2,3]);
-      expect(payload).to.eql(item);
-    }};
+  it('should get the right arguments', function () {
+    var item = { level: 'debug', body: 'stuff', _originalArgs: [1, 2, 3] };
+    var settings = {
+      reportLevel: 'debug',
+      checkIgnore: function (isUncaught, args, payload) {
+        expect(isUncaught).to.not.be.ok();
+        expect(args).to.eql([1, 2, 3]);
+        expect(payload).to.eql(item);
+      },
+    };
     expect(p.userCheckIgnore(logger)(item, settings)).to.be.ok();
   });
 });
 
-describe('urlIsSafeListed', function() {
+describe('urlIsSafeListed', function () {
   var item = {
     level: 'critical',
-    body: {trace: {frames: [
-      {filename: 'http://api.fake.com/v1/something'},
-      {filename: 'http://api.example.com/v1/something'},
-      {filename: 'http://api.fake.com/v2/something'}
-    ]}}
+    body: {
+      trace: {
+        frames: [
+          { filename: 'http://api.fake.com/v1/something' },
+          { filename: 'http://api.example.com/v1/something' },
+          { filename: 'http://api.fake.com/v2/something' },
+        ],
+      },
+    },
   };
   var traceChainItem = {
     level: 'critical',
-    body: {trace_chain: [{frames: [
-      {filename: 'http://api.fake.com/v1/something'},
-      {filename: 'http://api.example.com/v1/something'},
-      {filename: 'http://api.fake.com/v2/something'}
-    ]},
-    {frames: [
-      {filename: 'http://api.fake1.com/v2/something'},
-      {filename: 'http://api.example1.com/v2/something'},
-      {filename: 'http://api.fake1.com/v3/something'}
-    ]}
-    ]}
+    body: {
+      trace_chain: [
+        {
+          frames: [
+            { filename: 'http://api.fake.com/v1/something' },
+            { filename: 'http://api.example.com/v1/something' },
+            { filename: 'http://api.fake.com/v2/something' },
+          ],
+        },
+        {
+          frames: [
+            { filename: 'http://api.fake1.com/v2/something' },
+            { filename: 'http://api.example1.com/v2/something' },
+            { filename: 'http://api.fake1.com/v3/something' },
+          ],
+        },
+      ],
+    },
   };
-  it('should return true with no safelist', function() {
+  it('should return true with no safelist', function () {
     var settings = {
-      reportLevel: 'debug'
+      reportLevel: 'debug',
     };
     expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
     expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.be.ok();
   });
-  it('should return true with no trace', function() {
+  it('should return true with no trace', function () {
     var item = {
       level: 'critical',
-      body: {message: 'hey'}
+      body: { message: 'hey' },
     };
     var settings = {
       reportLevel: 'debug',
-      hostSafeList: ['fake.com', 'example.com']
+      hostSafeList: ['fake.com', 'example.com'],
     };
     expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
   });
-  it('should return true if at least one regex matches at least one filename in the trace', function() {
+  it('should return true if at least one regex matches at least one filename in the trace', function () {
     var settings = {
       reportLevel: 'debug',
-      hostSafeList: ['example.com']
+      hostSafeList: ['example.com'],
     };
     expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
     expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.be.ok();
   });
-  it('should return true if the filename is not a string', function() {
+  it('should return true if the filename is not a string', function () {
     var item = {
       level: 'critical',
-      body: {trace: {frames: [
-        {filename: {url: 'http://api.fake.com/v1/something'}},
-        {filename: {url: 'http://api.example.com/v1/something'}},
-        {filename: {url: 'http://api.fake.com/v2/something'}},
-      ]}}
+      body: {
+        trace: {
+          frames: [
+            { filename: { url: 'http://api.fake.com/v1/something' } },
+            { filename: { url: 'http://api.example.com/v1/something' } },
+            { filename: { url: 'http://api.fake.com/v2/something' } },
+          ],
+        },
+      },
     };
     var traceChainItem = {
       level: 'critical',
-      body: {trace_chain: [{frames: [
-        {filename: {url: 'http://api.fake.com/v1/something'}},
-        {filename: {url: 'http://api.example.com/v1/something'}},
-        {filename: {url: 'http://api.fake.com/v2/something'}},
-      ]},
-      {frames: [
-        {filename: {url: 'http://api.fake.com/v1/something'}},
-        {filename: {url: 'http://api.example.com/v1/something'}},
-        {filename: {url: 'http://api.fake.com/v2/something'}},
-      ]}
-      ]}
+      body: {
+        trace_chain: [
+          {
+            frames: [
+              { filename: { url: 'http://api.fake.com/v1/something' } },
+              { filename: { url: 'http://api.example.com/v1/something' } },
+              { filename: { url: 'http://api.fake.com/v2/something' } },
+            ],
+          },
+          {
+            frames: [
+              { filename: { url: 'http://api.fake.com/v1/something' } },
+              { filename: { url: 'http://api.example.com/v1/something' } },
+              { filename: { url: 'http://api.fake.com/v2/something' } },
+            ],
+          },
+        ],
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      hostSafeList: ['nope.com']
+      hostSafeList: ['nope.com'],
     };
     expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
     expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.be.ok();
   });
-  it('should return true if there is no frames key', function() {
+  it('should return true if there is no frames key', function () {
     var item = {
       level: 'critical',
-      body: {trace: {notframes: []}}
+      body: { trace: { notframes: [] } },
     };
     var traceChainItem = {
       level: 'critical',
-      body: {trace_chain: [
-        {notframes: []},
-        {notframes: []}
-      ]}
+      body: { trace_chain: [{ notframes: [] }, { notframes: [] }] },
     };
     var settings = {
       reportLevel: 'debug',
-      hostSafeList: ['nope.com']
+      hostSafeList: ['nope.com'],
     };
     expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
     expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.be.ok();
   });
-  it('should return true if there are no frames', function() {
+  it('should return true if there are no frames', function () {
     var item = {
       level: 'critical',
-      body: {trace: {frames: []}}
+      body: { trace: { frames: [] } },
     };
     var traceChainItem = {
       level: 'critical',
-      body: {trace_chain: [
-        {frames: []},
-        {frames: []}
-      ]}
+      body: { trace_chain: [{ frames: [] }, { frames: [] }] },
     };
     var settings = {
       reportLevel: 'debug',
-      hostSafeList: ['nope.com']
+      hostSafeList: ['nope.com'],
     };
     expect(p.urlIsSafeListed(logger)(item, settings)).to.be.ok();
     expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.be.ok();
   });
-  it('should return false if nothing in the safelist matches', function() {
+  it('should return false if nothing in the safelist matches', function () {
     var settings = {
       reportLevel: 'debug',
-      hostSafeList: ['baz\.com', 'foo\.com']
+      hostSafeList: ['baz.com', 'foo.com'],
     };
     expect(p.urlIsSafeListed(logger)(item, settings)).to.not.be.ok();
     expect(p.urlIsSafeListed(logger)(traceChainItem, settings)).to.not.be.ok();
   });
 });
 
-describe('urlIsNotBlockListed', function() {
+describe('urlIsNotBlockListed', function () {
   var item = {
     level: 'critical',
-    body: {trace: {frames: [
-      {filename: 'http://api.fake.com/v1/something'},
-      {filename: 'http://api.example.com/v1/something'},
-      {filename: 'http://api.fake.com/v2/something'}
-    ]}}
+    body: {
+      trace: {
+        frames: [
+          { filename: 'http://api.fake.com/v1/something' },
+          { filename: 'http://api.example.com/v1/something' },
+          { filename: 'http://api.fake.com/v2/something' },
+        ],
+      },
+    },
   };
   var traceChainItem = {
     level: 'critical',
-    body: {trace_chain: [{frames: [
-      {filename: 'http://api.fake.com/v1/something'},
-      {filename: 'http://api.example.com/v1/something'},
-      {filename: 'http://api.fake.com/v2/something'}
-    ]},
-    {frames: [
-      {filename: 'http://api.fake1.com/v2/something'},
-      {filename: 'http://api.example1.com/v2/something'},
-      {filename: 'http://api.fake1.com/v3/something'}
-    ]}
-    ]}
+    body: {
+      trace_chain: [
+        {
+          frames: [
+            { filename: 'http://api.fake.com/v1/something' },
+            { filename: 'http://api.example.com/v1/something' },
+            { filename: 'http://api.fake.com/v2/something' },
+          ],
+        },
+        {
+          frames: [
+            { filename: 'http://api.fake1.com/v2/something' },
+            { filename: 'http://api.example1.com/v2/something' },
+            { filename: 'http://api.fake1.com/v3/something' },
+          ],
+        },
+      ],
+    },
   };
-  it('should return true with no blocklist', function() {
+  it('should return true with no blocklist', function () {
     var settings = {
-      reportLevel: 'debug'
+      reportLevel: 'debug',
     };
     expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
     expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.be.ok();
   });
-  it('should return true with no trace', function() {
+  it('should return true with no trace', function () {
     var item = {
       level: 'critical',
-      body: {message: 'hey'}
+      body: { message: 'hey' },
     };
     var settings = {
       reportLevel: 'debug',
-      hostBlockList: ['fake.com', 'other.com']
+      hostBlockList: ['fake.com', 'other.com'],
     };
     expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
   });
-  it('should return false if any regex matches at least one filename in the trace', function() {
+  it('should return false if any regex matches at least one filename in the trace', function () {
     var settings = {
       reportLevel: 'debug',
-      hostBlockList: ['example.com', 'other.com']
+      hostBlockList: ['example.com', 'other.com'],
     };
     expect(p.urlIsNotBlockListed(logger)(item, settings)).to.not.be.ok();
-    expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.not.be.ok();
+    expect(
+      p.urlIsNotBlockListed(logger)(traceChainItem, settings),
+    ).to.not.be.ok();
   });
-  it('should return true if the filename is not a string', function() {
+  it('should return true if the filename is not a string', function () {
     var item = {
       level: 'critical',
-      body: {trace: {frames: [
-        {filename: {url: 'http://api.fake.com/v1/something'}},
-        {filename: {url: 'http://api.example.com/v1/something'}},
-        {filename: {url: 'http://api.fake.com/v2/something'}},
-      ]}}
+      body: {
+        trace: {
+          frames: [
+            { filename: { url: 'http://api.fake.com/v1/something' } },
+            { filename: { url: 'http://api.example.com/v1/something' } },
+            { filename: { url: 'http://api.fake.com/v2/something' } },
+          ],
+        },
+      },
     };
     var traceChainItem = {
       level: 'critical',
-      body: {trace_chain: [{frames: [
-        {filename: {url: 'http://api.fake.com/v1/something'}},
-        {filename: {url: 'http://api.example.com/v1/something'}},
-        {filename: {url: 'http://api.fake.com/v2/something'}},
-      ]},
-      {frames: [
-        {filename: {url: 'http://api.fake.com/v1/something'}},
-        {filename: {url: 'http://api.example.com/v1/something'}},
-        {filename: {url: 'http://api.fake.com/v2/something'}},
-      ]}
-      ]}
+      body: {
+        trace_chain: [
+          {
+            frames: [
+              { filename: { url: 'http://api.fake.com/v1/something' } },
+              { filename: { url: 'http://api.example.com/v1/something' } },
+              { filename: { url: 'http://api.fake.com/v2/something' } },
+            ],
+          },
+          {
+            frames: [
+              { filename: { url: 'http://api.fake.com/v1/something' } },
+              { filename: { url: 'http://api.example.com/v1/something' } },
+              { filename: { url: 'http://api.fake.com/v2/something' } },
+            ],
+          },
+        ],
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      hostBlockList: ['example.com', 'other.com']
+      hostBlockList: ['example.com', 'other.com'],
     };
     expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
     expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.be.ok();
   });
-  it('should return true if there is no frames key', function() {
+  it('should return true if there is no frames key', function () {
     var item = {
       level: 'critical',
-      body: {trace: {notframes: []}}
+      body: { trace: { notframes: [] } },
     };
     var traceChainItem = {
       level: 'critical',
-      body: {trace_chain: [
-        {notframes: []},
-        {notframes: []}
-      ]}
+      body: { trace_chain: [{ notframes: [] }, { notframes: [] }] },
     };
     var settings = {
       reportLevel: 'debug',
-      hostBlockList: ['nope.com']
+      hostBlockList: ['nope.com'],
     };
     expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
     expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.be.ok();
   });
-  it('should return true if there are no frames', function() {
+  it('should return true if there are no frames', function () {
     var item = {
       level: 'critical',
-      body: {trace: {frames: []}}
+      body: { trace: { frames: [] } },
     };
     var traceChainItem = {
       level: 'critical',
-      body: {trace_chain: [
-        {frames: []},
-        {frames: []}
-      ]}
+      body: { trace_chain: [{ frames: [] }, { frames: [] }] },
     };
     var settings = {
       reportLevel: 'debug',
-      hostBlockList: ['nope.com']
+      hostBlockList: ['nope.com'],
     };
     expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
     expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.be.ok();
   });
-  it('should return true if nothing in the blocklist matches', function() {
+  it('should return true if nothing in the blocklist matches', function () {
     var settings = {
       reportLevel: 'debug',
-      hostBlockList: ['baz\.com', 'foo\.com']
+      hostBlockList: ['baz.com', 'foo.com'],
     };
     expect(p.urlIsNotBlockListed(logger)(item, settings)).to.be.ok();
     expect(p.urlIsNotBlockListed(logger)(traceChainItem, settings)).to.be.ok();
   });
 });
 
-describe('messageIsIgnored', function() {
-  it('true if no ignoredMessages setting', function() {
+describe('messageIsIgnored', function () {
+  it('true if no ignoredMessages setting', function () {
     var item = {
       level: 'critical',
       body: {
-        trace: {exception: {message: 'bork bork'}},
-        message: {body: 'fuzz'}
-      }
+        trace: { exception: { message: 'bork bork' } },
+        message: { body: 'fuzz' },
+      },
     };
     var settings = {
-      reportLevel: 'debug'
+      reportLevel: 'debug',
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.be.ok();
   });
-  it('true if ignoredMessages is empty', function() {
+  it('true if ignoredMessages is empty', function () {
     var item = {
       level: 'critical',
       body: {
-        trace: {exception: {message: 'bork bork'}},
-        message: {body: 'fuzz'}
-      }
+        trace: { exception: { message: 'bork bork' } },
+        message: { body: 'fuzz' },
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: []
+      ignoredMessages: [],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.be.ok();
   });
-  it('true if no exception message', function() {
+  it('true if no exception message', function () {
     var item = {
       level: 'critical',
       body: {
-        trace: {exception: {}},
-        message: 'fuzz'
-      }
+        trace: { exception: {} },
+        message: 'fuzz',
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['bork bork', 'fuzz']
+      ignoredMessages: ['bork bork', 'fuzz'],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.be.ok();
   });
-  it('true if no ignoredMessages match', function() {
+  it('true if no ignoredMessages match', function () {
     var item = {
       level: 'critical',
       body: {
-        trace: {exception: {message: 'bork bork'}},
-        message: {body: 'fuzz'}
-      }
+        trace: { exception: { message: 'bork bork' } },
+        message: { body: 'fuzz' },
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['fake', 'stuff']
+      ignoredMessages: ['fake', 'stuff'],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.be.ok();
   });
-  it('false if any ignoredMessages match', function() {
+  it('false if any ignoredMessages match', function () {
     var item = {
       level: 'critical',
       body: {
-        trace: {exception: {message: 'bork bork'}},
-        message: {body: 'fuzz'}
-      }
+        trace: { exception: { message: 'bork bork' } },
+        message: { body: 'fuzz' },
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['bork bork', 'stuff']
+      ignoredMessages: ['bork bork', 'stuff'],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
   });
-  it('false if ignoredMessages regex match', function() {
+  it('false if ignoredMessages regex match', function () {
     var item = {
       level: 'critical',
       body: {
-        message: {body: 'This is an ignored message'}
-      }
+        message: { body: 'This is an ignored message' },
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['^This is an .{7} message$']
+      ignoredMessages: ['^This is an .{7} message$'],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
   });
-  it('false if ignoredMessages literal match', function() {
+  it('false if ignoredMessages literal match', function () {
     var item = {
       level: 'critical',
       body: {
-        message: {body: '{"data":{"messages":[{"message":"Unauthorized"}]}}'}
-      }
+        message: { body: '{"data":{"messages":[{"message":"Unauthorized"}]}}' },
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['{"data":{"messages":\\[']
+      ignoredMessages: ['{"data":{"messages":\\['],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
   });
-  it('false if ignoredMessages more literal regex matches', function() {
+  it('false if ignoredMessages more literal regex matches', function () {
     var item = {
       level: 'critical',
       body: {
-        message: {body: 'Match these characters: (*+?)'}
-      }
+        message: { body: 'Match these characters: (*+?)' },
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['\\(\\*\\+\\?\\)']
+      ignoredMessages: ['\\(\\*\\+\\?\\)'],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
   });
-  it('false if both trace and body message but ignoredMessages only match body', function() {
+  it('false if both trace and body message but ignoredMessages only match body', function () {
     var item = {
       level: 'critical',
       body: {
-        trace: {exception: {message: 'bork bork'}},
-        message: {body: 'fuzz'}
-      }
+        trace: { exception: { message: 'bork bork' } },
+        message: { body: 'fuzz' },
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['fuzz', 'stuff']
+      ignoredMessages: ['fuzz', 'stuff'],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
   });
-  it('false if ignoredMessages match something in body exception message', function() {
+  it('false if ignoredMessages match something in body exception message', function () {
     var item = {
       level: 'critical',
       body: {
-        trace: {frames: []},
-        message: {body: 'fuzz'}
-      }
+        trace: { frames: [] },
+        message: { body: 'fuzz' },
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['stuff', 'fuzz']
+      ignoredMessages: ['stuff', 'fuzz'],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
   });
-  it("true if trace_chain doesn't match", function() {
+  it("true if trace_chain doesn't match", function () {
     var item = {
       level: 'critical',
       body: {
         trace_chain: [
-          {exception: {message: 'inner bork'}},
-          {exception: {message: 'outer bork'}}
-        ]
-      }
+          { exception: { message: 'inner bork' } },
+          { exception: { message: 'outer bork' } },
+        ],
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['stuff', 'fuzz']
+      ignoredMessages: ['stuff', 'fuzz'],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.be.ok();
   });
-  it("false if first trace_chain trace matches", function() {
+  it('false if first trace_chain trace matches', function () {
     var item = {
       level: 'critical',
       body: {
         trace_chain: [
-          {exception: {message: 'inner stuff'}},
-          {exception: {message: 'outer bork'}}
-        ]
-      }
+          { exception: { message: 'inner stuff' } },
+          { exception: { message: 'outer bork' } },
+        ],
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['stuff', 'fuzz']
+      ignoredMessages: ['stuff', 'fuzz'],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
   });
-  it("false if last trace_chain trace matches", function() {
+  it('false if last trace_chain trace matches', function () {
     var item = {
       level: 'critical',
       body: {
         trace_chain: [
-          {exception: {message: 'inner bork'}},
-          {exception: {message: 'outer fuzz'}}
-        ]
-      }
+          { exception: { message: 'inner bork' } },
+          { exception: { message: 'outer fuzz' } },
+        ],
+      },
     };
     var settings = {
       reportLevel: 'debug',
-      ignoredMessages: ['stuff', 'fuzz']
+      ignoredMessages: ['stuff', 'fuzz'],
     };
     expect(p.messageIsIgnored(logger)(item, settings)).to.not.be.ok();
   });