Merge pull request #15 from AckeeCZ/change/logger-name-nonpretty

Add logger name to non-pretty loggers

Author: smolijar

CHANGELOG.md

@@ -4,9 +4,12 @@
 - lint issue due to changes in tslint 5.12.0
 - stream write function type
 - pretty streams created only when needed
+- logger name in pretty loggers
+
 
 ### Added
 - coveralls integration
+- automatic logger name in non-pretty loggers
 
 ## Changed
 - refactoring of express handlers

jest.config.js

@@ -8,4 +8,5 @@ module.exports = {
     collectCoverage: true,
     // testURL because of problems with jsdom https://github.com/jsdom/jsdom/issues/2304
     testURL: "http://localhost",
+    setupFilesAfterEnv: ['jest-extended'],
 };

package.json

@@ -57,14 +57,15 @@
     "coveralls": "^3.0.2",
     "express": "^4.16.3",
     "husky": "^0.14.3",
-    "jest": "^23.6.0",
+    "jest": "^24.1.0",
+    "jest-extended": "^0.11.1",
     "lint-staged": "^7.3.0",
     "npm-check": "^5.9.0",
     "prettier": "^1.14.3",
     "supertest": "^3.1.0",
-    "ts-jest": "^23.10.4",
+    "ts-jest": "^24.0.0",
     "tslint": "^5.11.0",
     "tslint-config-ackee": "^0.2.5",
-    "typescript": "^3.1.3"
+    "typescript": "^3.3.3333"
   }
 }

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,32 +94,34 @@ const defaultLogger = (options: AckeeLoggerOptions = {}): AckeeLogger => {
 };
 
 let rootLogger: AckeeLogger;
+let rootOptions: AckeeLoggerOptions;
 
 const parseLoggerData = (data: string | AckeeLoggerOptions = {}) => {
-    let moduleName: string | undefined;
+    let loggerName: string | undefined;
     let options: AckeeLoggerOptions = {};
     if (data) {
         if (isString(data)) {
-            moduleName = data as string;
+            loggerName = data;
         } else if (isObject(data)) {
-            options = data as AckeeLoggerOptions;
+            options = data;
         } else {
             throw new TypeError(`Invalid argument of type ${typeof data}`);
         }
     }
-    return { moduleName, options };
+    return { loggerName, options };
 };
 
 const loggerFactory = (data: string | AckeeLoggerOptions = {}): AckeeLogger => {
-    const { moduleName, options } = parseLoggerData(data);
+    const { loggerName, options } = parseLoggerData(data);
 
     if (!rootLogger) {
         rootLogger = defaultLogger(options);
+        rootOptions = options;
     }
-    if (!moduleName) {
+    if (!loggerName) {
         return rootLogger;
     }
-    return (rootLogger.child({ name: moduleName }) as any) as AckeeLogger;
+    return defaultLogger(Object.assign({ loggerName }, rootOptions));
 };
 
 const factoryProxy = new Proxy(loggerFactory, {

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

@@ -1,4 +1,5 @@
 import * as express from 'express';
+import 'jest-extended';
 import { Writable } from 'stream';
 import * as supertest from 'supertest';
 import { levels } from '../levels';
@@ -59,7 +60,7 @@ test('child logger has warning level', () =>
         loggerFactory({
             streams: [
                 testWriteStream(resolve, json => {
-                    expect(json.message).toBe('Hello');
+                    expect(json.message).toContain('Hello');
                     expect(json.level).toBe(levels.warn);
                 }),
             ],
@@ -182,3 +183,45 @@ test('silent stream does not write', () => {
     logger.fatal('Hello');
     expect(loggerWrites).not.toBeCalled();
 });
+
+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 => {
+            const loggerName = 'database';
+            loggerFactory({
+                pretty: false,
+                streams: [
+                    testWriteStream(resolve, json => {
+                        expect(json.message).toStartWith(`[${loggerName}] `);
+                    }),
+                ],
+            });
+            const logger = loggerFactory(loggerName);
+
+            logger.fatal(data.logData);
+        }));
+});
+
+exampleMessages.forEach(data => {
+    test(`logger name is propagated to pretty object with ${data.type} message`, () =>
+        new Promise(resolve => {
+            const loggerName = 'database';
+            loggerFactory({
+                pretty: true,
+                streams: [
+                    testWriteStream(resolve, json => {
+                        expect(json.name).toEqual(loggerName);
+                    }),
+                ],
+            });
+            const logger = loggerFactory(loggerName);
+
+            logger.fatal(data.logData);
+        }));
+});