♻️ Log to Sentry without transform stream

Author: Michal Vlasák

src/index.ts

@@ -123,13 +123,6 @@ const defaultLogger = (options: CosmasOptions & { loggerName?: string } = {}): C
     serializers.disablePaths(options.disableFields);
     serializers.enablePaths(options.enableFields);
 
-    if (options.sentry) {
-        const sentry = require('@sentry/node');
-        if (typeof options.sentry === 'string') {
-            sentry.init({ dsn: options.sentry });
-        }
-    }
-
     const isTesting = process.env.NODE_ENV === 'test';
     const defaultLevel: Level = options.defaultLevel || (isTesting ? 'silent' : 'debug');
     const messageKey = 'message'; // best option for Google Stackdriver,

src/sentry.ts

@@ -1,6 +1,6 @@
 import { captureException, captureMessage, Severity, withScope } from '@sentry/node';
-import { Transform, TransformCallback } from 'stream';
-import { CosmasOptions } from './interfaces';
+import { streamSym } from 'pino/lib/symbols';
+import { Cosmas } from '.';
 import { levels } from './levels';
 
 const reportToSentry = (obj: any) => {
@@ -23,20 +23,24 @@ const PINO_TO_SENTRY: { [key: number]: Severity } = {
     60: Severity.Critical,
 };
 
-export const createSentryTransformStream = (options: CosmasOptions): any => {
-    return class SentryTransformStream extends Transform {
-        // tslint:disable-next-line:function-name
-        public _transform(chunk: any, _encoding: string, callback: TransformCallback) {
-            const obj = JSON.parse(chunk);
-            if (obj.level >= (options.sentryLevel || levels.warn)) {
-                withScope((scope) => {
-                    scope.setLevel(PINO_TO_SENTRY[obj.level]);
-                    scope.setExtras(obj);
-                    reportToSentry(obj);
-                });
-            }
-            this.push(chunk);
-            callback();
+export const extendSentry = (logger: Cosmas, dsn: string | true) => {
+    const sentry = require('@sentry/node');
+    if (typeof dsn === 'string') {
+        sentry.init({ dsn });
+    }
+
+    const originalWrite = logger[streamSym].write;
+    // unfortunately, this is the only place in pino, we can hook onto, where we can be sure all
+    // the hooks, formatters and serializers are already applied
+    logger[streamSym].write = function (s: string) {
+        const obj = JSON.parse(s);
+        if (obj.level >= (logger.options.sentryLevel || levels.warn)) {
+            withScope((scope) => {
+                scope.setLevel(PINO_TO_SENTRY[obj.level]);
+                scope.setExtras(obj);
+                reportToSentry(obj);
+            });
         }
+        return originalWrite.call(this, s);
     };
 };

src/streams.ts

@@ -52,11 +52,6 @@ const initLoggerStreams = (
 
     streams = decorateStreams(streams, getDefaultTransformStream(options));
 
-    if (options.sentry) {
-        const { createSentryTransformStream } = require('./sentry');
-        streams = decorateStreams(streams, createSentryTransformStream(options));
-    }
-
     return streams;
 };
 

src/tests/sentry-mocked.test.ts

@@ -2,6 +2,7 @@ import omit = require('omit-deep');
 import { levels } from '../levels';
 
 let loggerFactory;
+let extendSentry;
 const scope: any = {};
 const withScope = jest.fn((fn) =>
     fn({
@@ -44,16 +45,17 @@ describe('sentry mocked', () => {
             };
         });
         loggerFactory = require('../index').default;
+        extendSentry = require('../sentry').extendSentry;
     });
     beforeEach(() => {
         captureException.mockReset();
         captureMessage.mockReset();
     });
     test('can create logger with options', () => {
         expect(() => loggerFactory()).not.toThrowError();
-        expect(() => loggerFactory({ sentry: true })).not.toThrowError();
+        expect(() => extendSentry(loggerFactory, true)).not.toThrowError();
         expect(init).not.toHaveBeenCalled();
-        expect(() => loggerFactory({ sentry: 'dummy' })).not.toThrowError();
+        expect(() => extendSentry(loggerFactory, 'dummy')).not.toThrowError();
         expect(init.mock.calls[0]).toMatchInlineSnapshot(`
             Array [
               Object {
@@ -71,6 +73,7 @@ describe('sentry mocked', () => {
                 sentry: 'DSN',
                 sentryLevel: levels.fatal,
             });
+            extendSentry(logger);
             captureMessage.mockImplementation(createCapture(resolve));
             // expect to trigger only fatal
             logger.trace('trace');
@@ -110,6 +113,7 @@ Object {
             const logger = loggerFactory({
                 sentry: 'DSN',
             });
+            extendSentry(logger);
             captureException.mockReset();
             captureException.mockImplementation(createCapture(resolve));
             logger.error(new Error());

src/tests/sentry.test.ts

@@ -3,13 +3,14 @@ import loggerFactory from '../index';
 describe('sentry not available', () => {
     beforeAll(() => {
         jest.mock('@sentry/node', () => {
-            throw new Error("Cannot find module '@sentry/node' from 'index.ts'");
+            throw new Error("Cannot find module '@sentry/node' from 'sentry.ts'");
         });
     });
     test('without sentry lib works by default, but crashes on provided', () => {
         expect(() => loggerFactory()).not.toThrowError();
-        expect(() => loggerFactory({ sentry: 'DSN' })).toThrowErrorMatchingInlineSnapshot(
-            `"Cannot find module '@sentry/node' from 'index.ts'"`
-        );
+        expect(() => {
+            const extendSentry = require('../sentry').extendSentry;
+            extendSentry(loggerFactory);
+        }).toThrowErrorMatchingInlineSnapshot(`"Cannot find module '@sentry/node' from 'sentry.ts'"`);
     });
 });