✨ Pass level and metadata to sentry scope

Related: #28

Author: smolijar

src/sentry.ts

@@ -1,11 +1,28 @@
 import { Transform, TransformCallback } from 'stream';
-import { captureException } from '@sentry/node';
+import { withScope, captureException, captureMessage, Severity } from '@sentry/node';
 
 class SentryTransformStream extends Transform {
     // tslint:disable-next-line:function-name
     public _transform(chunk: any, _encoding: string, callback: TransformCallback) {
+        const PINO_TO_SENTRY: { [key: number]: Severity } = {
+            10: Severity.Debug,
+            20: Severity.Debug,
+            30: Severity.Info,
+            40: Severity.Warning,
+            50: Severity.Error,
+            60: Severity.Critical,
+        };
         const obj = JSON.parse(chunk);
         captureException(obj);
+        withScope(scope => {
+            scope.setLevel(PINO_TO_SENTRY[obj.level]);
+            scope.setContext('data', obj);
+            if (obj.stack) {
+                captureException(obj);
+            } else {
+                captureMessage(obj.message || obj);
+            }
+        });
         this.push(chunk);
         callback();
     }

src/tests/sentry-mocked.test.ts

@@ -1,15 +1,37 @@
-import { testWriteStream } from './utils';
-import { setContext } from '@sentry/core';
-
 let loggerFactory;
-const captureException = jest.fn();
-const captureMessage = jest.fn();
+const scope: any = {};
+const withScope = jest.fn(fn =>
+    fn({
+        setContext: (key: string, val: any) => {
+            scope.context = { [key]: val };
+        },
+        setLevel: (level: any) => {
+            scope.level = level;
+        },
+    })
+);
+
+const createCapture = (cb = () => {}) => data => {
+    cb();
+    return { data, scope };
+};
+
+const captureException = jest.fn(createCapture());
+const captureMessage = jest.fn(createCapture());
 
 describe('sentry mocked', () => {
     beforeAll(() => {
         jest.mock('@sentry/node', () => {
             return {
                 captureException,
+                withScope,
+                Severity: {
+                    Debug: 'debug',
+                    Info: 'info',
+                    Warning: 'warning',
+                    Error: 'error',
+                    Critical: 'critical',
+                },
             };
         });
         loggerFactory = require('..').default;
@@ -19,15 +41,12 @@ describe('sentry mocked', () => {
         expect(() => loggerFactory({ sentryDsn: 'DSN' })).not.toThrowError();
     });
 
-    test('can use custom stream', async () => {
+    test('sentry is called with correct scope', async () => {
         await new Promise((resolve, reject) => {
             const logger = loggerFactory({
                 sentryDsn: 'DSN',
             });
-            captureException.mockImplementation(x => {
-                resolve();
-                console.log({ captureException: x });
-            });
+            captureException.mockImplementation(createCapture(resolve));
             logger.info('Foo');
         });
         expect(captureException.mock.calls[0]).toMatchInlineSnapshot(`
@@ -39,5 +58,24 @@ describe('sentry mocked', () => {
               },
             ]
         `);
+        expect(captureException.mock.results[0].value).toMatchInlineSnapshot(`
+            Object {
+              "data": Object {
+                "level": 30,
+                "message": "Foo",
+                "v": 1,
+              },
+              "scope": Object {
+                "context": Object {
+                  "data": Object {
+                    "level": 30,
+                    "message": "Foo",
+                    "v": 1,
+                  },
+                },
+                "level": "info",
+              },
+            }
+        `);
     });
 });