deps(sentry): move from raven to @sentry/node

build/build-bundle.js

@@ -94,7 +94,7 @@ async function build(entryPath, distPath, opts = {minify: true}) {
     'intl-pluralrules',
     'intl',
     'pako/lib/zlib/inflate.js',
-    'raven',
+    '@sentry/node',
     'source-map',
     'ws',
     require.resolve('../lighthouse-core/gather/connections/cri.js'),

lighthouse-core/lib/sentry.js

@@ -7,8 +7,10 @@
 
 const log = require('lighthouse-logger');
 
-/** @typedef {import('raven').CaptureOptions} CaptureOptions */
-/** @typedef {import('raven').ConstructorOptions} ConstructorOptions */
+/** @typedef {import('@sentry/node').Breadcrumb} Breadcrumb */
+/** @typedef {import('@sentry/node').NodeClient} NodeClient */
+/** @typedef {import('@sentry/node').NodeOptions} NodeOptions */
+/** @typedef {import('@sentry/node').Severity} Severity */
 
 const SENTRY_URL = 'https://a6bb0da87ee048cc9ae2a345fc09ab2e:63a7029f46f74265981b7e005e0f69f8@sentry.io/174697';
 
@@ -21,30 +23,30 @@ const SAMPLED_ERRORS = [
   // e.g.: {pattern: /No.*node with given id/, rate: 0.01},
 ];
 
-const noop = () => {};
+const noop = () => { };
 
 /**
  * A delegate for sentry so that environments without error reporting enabled will use
  * noop functions and environments with error reporting will call the actual Sentry methods.
  */
 const sentryDelegate = {
   init,
-  /** @type {(message: string, options?: CaptureOptions) => void} */
+  /** @type {(message: string, level?: Severity) => void} */
   captureMessage: noop,
-  /** @type {(breadcrumb: any) => void} */
+  /** @type {(breadcrumb: Breadcrumb) => void} */
   captureBreadcrumb: noop,
   /** @type {() => any} */
   getContext: noop,
-  /** @type {(error: Error, options?: CaptureOptions) => Promise<void>} */
-  captureException: async () => {},
+  /** @type {(error: Error, options: {level?: string, tags?: {[key: string]: any}, extra?: {[key: string]: any}}) => Promise<void>} */
+  captureException: async () => { },
   _shouldSample() {
     return SAMPLE_RATE >= Math.random();
   },
 };
 
 /**
  * When called, replaces noops with actual Sentry implementation.
- * @param {{url: string, flags: LH.CliFlags, environmentData: ConstructorOptions}} opts
+ * @param {{url: string, flags: LH.CliFlags, environmentData: NodeOptions}} opts
  */
 function init(opts) {
   // If error reporting is disabled, leave the functions as a noop
@@ -58,15 +60,26 @@ function init(opts) {
   }
 
   try {
-    const Sentry = require('raven');
-    const sentryConfig = Object.assign({}, opts.environmentData,
-      {captureUnhandledRejections: true});
-    Sentry.config(SENTRY_URL, sentryConfig).install();
+    const Sentry = require('@sentry/node');
+    Sentry.init({
+      ...opts.environmentData,
+      dsn: SENTRY_URL,
+      captureUnhandledRejections: true,
+    });
+
+    const context = {
+      ...opts.environmentData.extra,
+      ...opts.flags.throttling,
+      url: opts.url,
+      formFactor: opts.flags.formFactor,
+      throttlingMethod: opts.flags.throttlingMethod,
+    };
+    Sentry.setExtras(context);
 
     // Have each delegate function call the corresponding sentry function by default
     sentryDelegate.captureMessage = (...args) => Sentry.captureMessage(...args);
-    sentryDelegate.captureBreadcrumb = (...args) => Sentry.captureBreadcrumb(...args);
-    sentryDelegate.getContext = () => Sentry.getContext();
+    sentryDelegate.captureBreadcrumb = (...args) => Sentry.addBreadcrumb(...args);
+    sentryDelegate.getContext = () => context;
 
     // Keep a record of exceptions per audit/gatherer so we can just report once
     const sentryExceptionCache = new Map();
@@ -108,20 +121,26 @@ function init(opts) {
       }
 
       return new Promise(resolve => {
-        Sentry.captureException(err, opts, () => resolve());
+        Sentry.withScope(scope => {
+          if (opts.level) {
+            // @ts-ignore - allow any string.
+            scope.setLevel(opts.level);
+          }
+          if (opts.tags) {
+            scope.setTags(opts.tags);
+          }
+          if (opts.extra) {
+            scope.setExtras(opts.extra);
+          }
+          Sentry.captureException(err);
+          resolve(); // TODO: idk ??
+        });
       });
     };
-
-    const context = Object.assign({
-      url: opts.url,
-      formFactor: opts.flags.formFactor,
-      throttlingMethod: opts.flags.throttlingMethod,
-    }, opts.flags.throttling);
-    Sentry.mergeContext({extra: Object.assign({}, opts.environmentData.extra, context)});
   } catch (e) {
     log.warn(
       'sentry',
-      'Could not load raven library, errors will not be reported.'
+      'Could not load Sentry, errors will not be reported.'
     );
   }
 }

lighthouse-core/runner.js

@@ -48,6 +48,7 @@ class Runner {
       Sentry.captureBreadcrumb({
         message: 'Run started',
         category: 'lifecycle',
+        // TODO is this really needed? the 'extra' data is already set at the end of sentry.js ... why put in breadcrumb?
         data: sentryContext?.extra,
       });
 

lighthouse-core/test/lib/sentry-test.js

@@ -5,9 +5,9 @@
  */
 'use strict';
 
-jest.mock('raven');
+jest.mock('@sentry/node');
 
-const raven = require('raven');
+const sentryNode = require('@sentry/node');
 const Sentry = require('../../lib/sentry.js');
 
 /* eslint-env jest */
@@ -27,9 +27,14 @@ describe('Sentry', () => {
     // We want to have a fresh state for every test.
     originalSentry = {...Sentry};
 
-    raven.config = jest.fn().mockReturnValue({install: jest.fn()});
-    raven.mergeContext = jest.fn();
-    raven.captureException = jest.fn().mockImplementation((err, opts, cb) => cb());
+    sentryNode.init = jest.fn().mockReturnValue({install: jest.fn()});
+    sentryNode.setExtras = jest.fn();
+    sentryNode.captureException = jest.fn();
+    sentryNode.withScope = (fn) => fn({
+      setLevel: () => {},
+      setTags: () => {},
+      setExtras: () => {},
+    });
     Sentry._shouldSample = jest.fn().mockReturnValue(true);
   });
 
@@ -41,15 +46,15 @@ describe('Sentry', () => {
   describe('.init', () => {
     it('should noop when !enableErrorReporting', () => {
       Sentry.init({url: 'http://example.com', flags: {}});
-      expect(raven.config).not.toHaveBeenCalled();
+      expect(sentryNode.init).not.toHaveBeenCalled();
       Sentry.init({url: 'http://example.com', flags: {enableErrorReporting: false}});
-      expect(raven.config).not.toHaveBeenCalled();
+      expect(sentryNode.init).not.toHaveBeenCalled();
     });
 
     it('should noop when not picked for sampling', () => {
       Sentry._shouldSample.mockReturnValue(false);
       Sentry.init({url: 'http://example.com', flags: {enableErrorReporting: true}});
-      expect(raven.config).not.toHaveBeenCalled();
+      expect(sentryNode.init).not.toHaveBeenCalled();
     });
 
     it('should initialize the raven client when enableErrorReporting', () => {
@@ -63,14 +68,12 @@ describe('Sentry', () => {
         environmentData: {},
       });
 
-      expect(raven.config).toHaveBeenCalled();
-      expect(raven.mergeContext).toHaveBeenCalled();
-      expect(raven.mergeContext.mock.calls[0][0]).toEqual({
-        extra: {
-          url: 'http://example.com',
-          formFactor: 'desktop',
-          throttlingMethod: 'devtools',
-        },
+      expect(sentryNode.init).toHaveBeenCalled();
+      expect(sentryNode.setExtras).toHaveBeenCalled();
+      expect(sentryNode.setExtras.mock.calls[0][0]).toEqual({
+        url: 'http://example.com',
+        formFactor: 'desktop',
+        throttlingMethod: 'devtools',
       });
     });
   });
@@ -81,8 +84,8 @@ describe('Sentry', () => {
       const error = new Error('oops');
       await Sentry.captureException(error);
 
-      expect(raven.captureException).toHaveBeenCalled();
-      expect(raven.captureException.mock.calls[0][0]).toBe(error);
+      expect(sentryNode.captureException).toHaveBeenCalled();
+      expect(sentryNode.captureException.mock.calls[0][0]).toBe(error);
     });
 
     it('should skip expected errors', async () => {
@@ -91,7 +94,7 @@ describe('Sentry', () => {
       error.expected = true;
       await Sentry.captureException(error);
 
-      expect(raven.captureException).not.toHaveBeenCalled();
+      expect(sentryNode.captureException).not.toHaveBeenCalled();
     });
 
     it('should skip duplicate audit errors', async () => {
@@ -100,7 +103,7 @@ describe('Sentry', () => {
       await Sentry.captureException(error, {tags: {audit: 'my-audit'}});
       await Sentry.captureException(error, {tags: {audit: 'my-audit'}});
 
-      expect(raven.captureException).toHaveBeenCalledTimes(1);
+      expect(sentryNode.captureException).toHaveBeenCalledTimes(1);
     });
 
     it('should still allow different audit errors', async () => {
@@ -110,7 +113,7 @@ describe('Sentry', () => {
       await Sentry.captureException(errorA, {tags: {audit: 'my-audit'}});
       await Sentry.captureException(errorB, {tags: {audit: 'my-audit'}});
 
-      expect(raven.captureException).toHaveBeenCalledTimes(2);
+      expect(sentryNode.captureException).toHaveBeenCalledTimes(2);
     });
 
     it('should skip duplicate gatherer errors', async () => {
@@ -119,7 +122,7 @@ describe('Sentry', () => {
       await Sentry.captureException(error, {tags: {gatherer: 'my-gatherer'}});
       await Sentry.captureException(error, {tags: {gatherer: 'my-gatherer'}});
 
-      expect(raven.captureException).toHaveBeenCalledTimes(1);
+      expect(sentryNode.captureException).toHaveBeenCalledTimes(1);
     });
   });
 });

package.json

@@ -183,6 +183,7 @@
     "webtreemap-cdt": "^3.2.1"
   },
   "dependencies": {
+    "@sentry/node": "^5.4.3",
     "axe-core": "4.3.5",
     "chrome-launcher": "^0.15.0",
     "configstore": "^5.0.1",
@@ -204,7 +205,6 @@
     "open": "^8.4.0",
     "parse-cache-control": "1.0.1",
     "ps-list": "^8.0.0",
-    "raven": "^2.2.1",
     "robots-parser": "^3.0.0",
     "semver": "^5.3.0",
     "speedline-core": "^1.4.3",