feat: migrate to @sentry/node

- Refactored `sentry()` params to use destructuring with defaults, so the normalization is no longer necessary
- Added `extras` to use Sentry’s `scope.setExtra()` to enrich the error data
- Added `captureReturnedErrors` option to capture errors from other middlewares that return errors instead of throwing, e.g., `graphql-shield` https://github.com/maticzav/graphql-shield#custom-errors

Closes #29

Author: herkulano

src/index.ts

@@ -1,10 +1,19 @@
-import { config as raven, captureException, ConstructorOptions } from 'raven'
+import * as Sentry from '@sentry/node'
+import * as _ from 'lodash'
+
 import { IMiddlewareFunction } from 'graphql-middleware/dist/types'
 
+interface Extra {
+  name: string
+  path: string
+}
+
 // Options for graphql-middleware-sentry
 export interface Options {
   dsn: string
-  config?: ConstructorOptions
+  config?: Sentry.NodeOptions
+  extras?: Extra[]
+  captureReturnedErrors?: boolean
   forwardErrors?: boolean
 }
 
@@ -14,41 +23,45 @@ export class SentryError extends Error {
   }
 }
 
-function normalizeOptions(options: Options): Options {
+export const sentry = ({
+  dsn,
+  config = {},
+  extras = [],
+  captureReturnedErrors = false,
+  forwardErrors = false,
+}: Options): IMiddlewareFunction => {
   // Check if Sentry DSN is present
-  if (!options.dsn) {
+  if (!dsn) {
     throw new SentryError(`Missing dsn parameter in configuration.`)
   }
 
-  return {
-    dsn: options.dsn,
-    config: options.config !== undefined ? options.config : {},
-    forwardErrors:
-      options.forwardErrors !== undefined ? options.forwardErrors : false,
-  }
-}
-
-export const sentry = (_options: Options): IMiddlewareFunction => {
-  const options = normalizeOptions(_options)
-
-  // Configure and install Raven
-  raven(options.dsn, options.config).install()
+  // Init Sentry
+  Sentry.init({ dsn, ...config })
 
   // Return middleware resolver
   return async function(resolve, parent, args, ctx, info) {
     try {
       const res = await resolve(parent, args, ctx, info)
+      if (captureReturnedErrors && res instanceof Error) {
+        captureException(res, ctx, extras)
+      }
       return res
     } catch (err) {
-      // Capture exception
-      captureException(err, {
-        req: ctx.request,
-      })
+      captureException(err, ctx, extras)
 
       // Forward error
-      if (options.forwardErrors) {
+      if (forwardErrors) {
         throw err
       }
     }
   }
 }
+
+function captureException(err, ctx, extras: Extra[]) {
+  Sentry.withScope(scope => {
+    extras.forEach(extra => {
+      scope.setExtra(extra.name, _.get(ctx, extra.path))
+    })
+    Sentry.captureException(err)
+  })
+}