Add logger name to pretty and non-pretty loggers

Author: Michal Vlasák

src/index.ts

@@ -49,13 +49,14 @@ const maxLevelWrite: pino.WriteFn = function(this: any, data: object): void {
     }
 };
 
-const defaultLogger = (options: AckeeLoggerOptions = {}): AckeeLogger => {
+const defaultLogger = (options: AckeeLoggerOptions & { loggerName?: string } = {}): AckeeLogger => {
     serializers.disablePaths(options.disableFields);
     serializers.enablePaths(options.enableFields);
 
     const isTesting = process.env.NODE_ENV === 'test';
     const defaultLevel: Level = options.defaultLevel || (isTesting ? 'silent' : 'debug');
-    const streams = initLoggerStreams(defaultLevel, options);
+    const messageKey = options.pretty ? 'msg' : 'message'; // "message" is the best option for Google Stackdriver,
+    const streams = initLoggerStreams(defaultLevel, Object.assign({}, options, { messageKey }));
 
     if (!options.ignoredHttpMethods) {
         options.ignoredHttpMethods = ['OPTIONS'];
@@ -66,9 +67,9 @@ const defaultLogger = (options: AckeeLoggerOptions = {}): AckeeLogger => {
         Object.assign(
             {},
             {
+                messageKey,
                 base: {},
                 level: defaultLevel,
-                messageKey: options.pretty ? 'msg' : 'message', // "message" is the best option for Google Stackdriver,
                 serializers: serializers.serializers,
                 timestamp: false,
             },
@@ -93,15 +94,16 @@ const defaultLogger = (options: AckeeLoggerOptions = {}): AckeeLogger => {
 };
 
 let rootLogger: AckeeLogger;
+let rootOptions: AckeeLoggerOptions;
 
 const parseLoggerData = (data: string | AckeeLoggerOptions = {}) => {
     let moduleName: string | undefined;
     let options: AckeeLoggerOptions = {};
     if (data) {
         if (isString(data)) {
-            moduleName = data as string;
+            moduleName = data;
         } else if (isObject(data)) {
-            options = data as AckeeLoggerOptions;
+            options = data;
         } else {
             throw new TypeError(`Invalid argument of type ${typeof data}`);
         }
@@ -114,11 +116,12 @@ const loggerFactory = (data: string | AckeeLoggerOptions = {}): AckeeLogger => {
 
     if (!rootLogger) {
         rootLogger = defaultLogger(options);
+        rootOptions = options;
     }
     if (!moduleName) {
         return rootLogger;
     }
-    return (rootLogger.child({ name: moduleName }) as any) as AckeeLogger;
+    return defaultLogger(Object.assign({ loggerName: moduleName }, rootOptions));
 };
 
 const factoryProxy = new Proxy(loggerFactory, {

src/stackdriver.ts

@@ -13,9 +13,6 @@ class StackDriverFormatStream extends Transform {
     // tslint:disable-next-line:function-name
     public _transform(chunk: any, _encoding: string, callback: (error?: Error | undefined, data?: any) => void) {
         const obj = JSON.parse(chunk);
-        if (obj.name) {
-            obj.message = `[${obj.name}] ${obj.message}`;
-        }
         obj.severity = PINO_TO_STACKDRIVER[obj.level] || 'UNKNOWN';
 
         this.push(`${JSON.stringify(obj)}\n`);

src/streams.ts

@@ -6,18 +6,33 @@ import { AckeeLoggerOptions, AckeeLoggerStream } from './interfaces';
 import { levels } from './levels';
 import { StackDriverFormatStream } from './stackdriver';
 
+const isString = (x: any) => typeof x === 'string' || x instanceof String;
+
 const pkgJson = JSON.parse(fs.readFileSync(path.resolve(path.join(__dirname, '..', 'package.json')), 'utf8'));
 
-class DefaultTransformStream extends Transform {
-    // tslint:disable-next-line:function-name
-    public _transform(chunk: any, _encoding: string, callback: (error?: Error | undefined, data?: any) => void) {
-        const obj = JSON.parse(chunk);
-        obj.pkgVersion = pkgJson.version;
+const getDefaultTransformStream = (options: AckeeLoggerOptions & { messageKey: string; loggerName?: string }) => {
+    class DefaultTransformStream extends Transform {
+        // tslint:disable-next-line:function-name
+        public _transform(chunk: any, _encoding: string, callback: (error?: Error | undefined, data?: any) => void) {
+            const obj = JSON.parse(chunk);
+            obj.pkgVersion = pkgJson.version;
+            const loggerName = options.loggerName;
+            if (options.pretty) {
+                obj['name\0'] = obj.name; // add null character so that it is not interpreted by pino-pretty but still visible to user unchanged
+                delete obj.name;
+                if (loggerName) {
+                    obj.name = loggerName;
+                }
+            } else if (obj[options.messageKey] && isString(obj[options.messageKey]) && loggerName) {
+                obj[options.messageKey] = `[${loggerName}] ${obj[options.messageKey]}`;
+            }
 
-        this.push(`${JSON.stringify(obj)}\n`);
-        callback();
+            this.push(`${JSON.stringify(obj)}\n`);
+            callback();
+        }
     }
-}
+    return DefaultTransformStream;
+};
 
 const decorateStreams = <T extends Transform>(streams: AckeeLoggerStream[], streamClass: new () => T) => {
     return streams.map(stream => {
@@ -31,7 +46,10 @@ const decorateStreams = <T extends Transform>(streams: AckeeLoggerStream[], stre
     });
 };
 
-const initLoggerStreams = (defaultLevel: pino.LevelWithSilent, options: AckeeLoggerOptions = {}) => {
+const initLoggerStreams = (
+    defaultLevel: pino.LevelWithSilent,
+    options: AckeeLoggerOptions & { messageKey: string; loggerName?: string }
+) => {
     let streams: AckeeLoggerStream[];
     if (options.streams) {
         streams = options.streams;
@@ -54,7 +72,7 @@ const initLoggerStreams = (defaultLevel: pino.LevelWithSilent, options: AckeeLog
         streams = decorateStreams(streams, StackDriverFormatStream);
     }
 
-    streams = decorateStreams(streams, DefaultTransformStream);
+    streams = decorateStreams(streams, getDefaultTransformStream(options));
 
     return streams;
 };

src/tests/index.test.ts

@@ -184,18 +184,44 @@ test('silent stream does not write', () => {
     expect(loggerWrites).not.toBeCalled();
 });
 
-test('logger name is shown in non-pretty message', () =>
-    new Promise((resolve, reject) => {
-        const loggerName = 'database';
-        loggerFactory({
-            streams: [
-                testWriteStream(resolve, json => {
-                    expect(json.name).toBe(loggerName);
-                    expect(json.message).toStartWith(`[${loggerName}] `);
-                }),
-            ],
-        });
-        const logger = loggerFactory(loggerName);
+const exampleMessages = [
+    { type: 'simple', logData: 'Hello' },
+    { type: 'message-key', logData: { message: 'You gotta do, what you gotta do' } },
+    { type: 'msg-key', logData: { message: 'Mirror, mirror, on the wall' } },
+];
+
+exampleMessages.forEach(data => {
+    test(`logger name is shown in non-pretty ${data.type} message`, () =>
+        new Promise((resolve, reject) => {
+            const loggerName = 'database';
+            loggerFactory({
+                pretty: false,
+                streams: [
+                    testWriteStream(resolve, json => {
+                        expect(json.message).toStartWith(`[${loggerName}] `);
+                    }),
+                ],
+            });
+            const logger = loggerFactory(loggerName);
 
-        logger.fatal('Hello');
-    }));
+            logger.fatal(data.logData);
+        }));
+});
+
+exampleMessages.forEach(data => {
+    test(`logger name is propagated to pretty object with ${data.type} message`, () =>
+        new Promise((resolve, reject) => {
+            const loggerName = 'database';
+            loggerFactory({
+                pretty: true,
+                streams: [
+                    testWriteStream(resolve, json => {
+                        expect(json.name).toEqual(loggerName);
+                    }),
+                ],
+            });
+            const logger = loggerFactory(loggerName);
+
+            logger.fatal(data.logData);
+        }));
+});