Merge pull request #23 from AckeeCZ/feat/inherit-name

✨ Update factory interface

Author: smoliji

README.md

@@ -21,8 +21,6 @@ Simple pino-based logger for all your writing needs
 
 ## How to use
 
-First step is to create a root logger. Its configuration can be specified on creation and it will be used for all other loggers created.
-
 ### Import the logger factory
 
 ```js
@@ -35,15 +33,15 @@ or with import
 import loggerFactory from 'cosmas';
 ```
 
-### Create root logger with default configuration
+### Create logger with default configuration
 
 ```js
 const logger = loggerFactory; // factory itself is a logger
 // or
 const logger = loggerFactory();
 ```
 
-### Create root logger with custom configuration
+### Create logger with custom configuration
 
 ```js
 const logger = loggerFactory({
@@ -52,18 +50,18 @@ const logger = loggerFactory({
 });
 ```
 
-Note: If you want to specify custom configuration it must be done **in the first require** of `cosmas`. Otherwise, default configuration will be used.
-
 See **Options** for a list of possible options.
 
-After you create a root logger, you may use it or you can create a child logger.
+### Child loggers
+Every logger can be used to create a *child* logger. Child logger inherits all configuration of its *parent* and cannot override them.
+
+Child logger can specify its own *name* which is then concatenated with parent's *name*. Therefore the child logger name is `parentNamechildName`.
 
 ```js
-const databaseLogger = loggerFactory('database')
+const parentLogger = loggerFactory('database', { pretty: false });
+const childLogger = parentLogger('.updates');
 ```
 
-The only difference between root logger and a child logger is that the child logger will print its name in each log message.
-
 ## Logger usage
 
 Logger itself is an enhanced and specifically configured `pino` instance, so you may use all basic `pino` log methods

src/index.ts

@@ -18,12 +18,20 @@ export interface AckeeLogger extends PinoLogger {
     express: AckeeLoggerExpressMiddleware;
     expressError: ErrorRequestHandler;
     stream: Writable;
+    (childName: string): any;
 }
 
 export interface AckeeLoggerFactory extends AckeeLogger {
-    (data: string | AckeeLoggerOptions): AckeeLogger;
+    (data?: string | AckeeLoggerOptions): AckeeLogger;
 }
 
+const makeCallable = <T extends object, F extends (...args: any[]) => any>(obj: T, fun: F): T & F =>
+    new Proxy(fun as any, {
+        get: (_target, key) => (obj as any)[key],
+    });
+
+const objEmpty = (obj: object) => Object.keys(obj).length === 0;
+
 // This is a custom slightly edited version of pino-multistream's write method, which adds support for maximum log level
 // The original version was pino-multistream 4.2.0 (commit bf7941f) - https://github.com/pinojs/pino-multi-stream/blob/bf7941f77661b6c14dd40840ff4a4db6897f08eb/multistream.js#L43
 const maxLevelWrite: pino.WriteFn = function(this: any, data: object): void {
@@ -95,9 +103,6 @@ const defaultLogger = (options: AckeeLoggerOptions & { loggerName?: string } = {
     });
 };
 
-let rootLogger: AckeeLogger;
-let rootOptions: AckeeLoggerOptions;
-
 const parseLoggerData = (data: string | AckeeLoggerOptions = {}) => {
     let loggerName: string | undefined;
     let options: AckeeLoggerOptions = {};
@@ -113,21 +118,19 @@ const parseLoggerData = (data: string | AckeeLoggerOptions = {}) => {
     return { loggerName, options };
 };
 
-const loggerFactory = (data: string | AckeeLoggerOptions = {}): AckeeLogger => {
+const loggerFactory = (data: string | AckeeLoggerOptions = {}, loggerOptions: AckeeLoggerOptions = {}): AckeeLogger => {
     const { loggerName, options } = parseLoggerData(data);
+    loggerOptions = objEmpty(options) ? loggerOptions : options;
+    const logger = defaultLogger(Object.assign({ loggerName }, loggerOptions));
 
-    if (!rootLogger) {
-        rootLogger = defaultLogger(options);
-        rootOptions = options;
-    }
-    if (!loggerName) {
-        return rootLogger;
-    }
-    return defaultLogger(Object.assign({ loggerName }, rootOptions));
+    const loggerProxy = makeCallable(logger, (childName: string) => {
+        const childLoggerName = [loggerName, childName].join('');
+        const childOptions = loggerOptions;
+        return loggerFactory(childLoggerName, childOptions);
+    });
+    return loggerProxy;
 };
 
-const factoryProxy = new Proxy(loggerFactory, {
-    get: (target, key) => (target() as any)[key],
-}) as AckeeLoggerFactory;
+const factoryProxy = makeCallable(loggerFactory(), loggerFactory);
 
 export default factoryProxy;

src/tests/index.test.ts

@@ -1,14 +1,9 @@
 import 'jest-extended';
+import isString = require('lodash.isstring');
 import { Writable } from 'stream';
+import loggerFactory from '..';
 import { levels } from '../levels';
 
-let loggerFactory;
-
-beforeEach(() => {
-    jest.resetModules();
-    loggerFactory = require('..').default;
-});
-
 test('can create default logger', () => {
     const logger = loggerFactory();
     expect(logger).toBeDefined();
@@ -17,6 +12,13 @@ test('can create default logger', () => {
 test('can create named logger', () => {
     const logger = loggerFactory('myApp');
     expect(logger).toBeDefined();
+    expect((logger.options as any).loggerName).toBe('myApp');
+});
+
+test.skip('can create logger with options', () => { // TODO: will work after pretty mechanics update - broken bc of deps update
+    const logger = loggerFactory({ pretty: true });
+    expect(logger).toBeDefined();
+    expect(logger.options.pretty).toBe(true);
 });
 
 const testWriteStream = (resolve, assert) => ({
@@ -55,15 +57,15 @@ test('can use warning level', () =>
 
 test('child logger has warning level', () =>
     new Promise((resolve, reject) => {
-        loggerFactory({
+        const rootLogger = loggerFactory({
             streams: [
                 testWriteStream(resolve, json => {
                     expect(json.message).toContain('Hello');
                     expect(json.level).toBe(levels.warn);
                 }),
             ],
         });
-        const childLogger = loggerFactory('child');
+        const childLogger = rootLogger('child');
 
         childLogger.warning('Hello');
     }));
@@ -126,34 +128,74 @@ exampleMessages.forEach(data => {
     test(`logger name is shown in non-pretty ${data.type} message`, () =>
         new Promise(resolve => {
             const loggerName = 'database';
-            loggerFactory({
+            const rootLogger = loggerFactory({
                 pretty: false,
                 streams: [
                     testWriteStream(resolve, json => {
                         expect(json.message).toStartWith(`[${loggerName}] `);
                     }),
                 ],
             });
-            const logger = loggerFactory(loggerName);
+            const logger = rootLogger(loggerName);
 
-            logger.fatal(data.logData);
+            if (isString(data.logData)) {
+                logger.fatal(data.logData);
+            } else {
+                logger.fatal(data.logData, 'Data');
+            }
         }));
 });
 
 exampleMessages.forEach(data => {
     test(`logger name is propagated to pretty object with ${data.type} message`, () =>
         new Promise(resolve => {
             const loggerName = 'database';
-            loggerFactory({
+            const rootLogger = loggerFactory({
                 pretty: true,
                 streams: [
                     testWriteStream(resolve, json => {
                         expect(json.name).toEqual(loggerName);
                     }),
                 ],
             });
-            const logger = loggerFactory(loggerName);
+            const logger = rootLogger(loggerName);
 
-            logger.fatal(data.logData);
+            if (isString(data.logData)) {
+                logger.fatal(data.logData);
+            } else {
+                logger.fatal(data.logData, 'Data');
+            }
         }));
 });
+
+test('multiple logger configs are not affected', () => {
+    const primaryLogger = loggerFactory({ disableStackdriverFormat: true, ignoredHttpMethods: ['POST'] });
+    const secondaryLogger = loggerFactory({ disableStackdriverFormat: false, ignoredHttpMethods: ['GET'] });
+
+    expect(primaryLogger.options.disableStackdriverFormat).toBe(true);
+    expect(primaryLogger.options.ignoredHttpMethods).toIncludeSameMembers(['POST']);
+    expect(secondaryLogger.options.disableStackdriverFormat).toBe(false);
+    expect(secondaryLogger.options.ignoredHttpMethods).toIncludeSameMembers(['GET']);
+});
+
+test('Child logger takes parent config', () => {
+    const logger = loggerFactory({ disableStackdriverFormat: true });
+    const childLogger = logger('child');
+
+    expect(childLogger.options.disableStackdriverFormat).toBe(true);
+});
+
+test('Child logger inherits parent name', () => {
+    const logger = loggerFactory('parent', { disableStackdriverFormat: true });
+    const childLogger = logger('child');
+
+    expect(childLogger.options.loggerName).toBe('parentchild');
+});
+
+test('Child logger can create another child', () => {
+    const logger = loggerFactory('parent', { disableStackdriverFormat: true });
+    const childLogger = logger('child');
+    const kid = childLogger('grandkid');
+
+    expect(kid.options.loggerName).toBe('parentchildgrandkid');
+});