Add README, remove useless files, refactor

Author: Michal Vlasák

README.md

@@ -0,0 +1,111 @@
+# Simple pino-based logger setup for Ackee purposes
+
+## 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.
+
+### Create root logger with default configuration
+
+```js
+const logger = require('ackee-node-logger');
+// of
+const logger = require('ackee-node-logger')();
+```
+
+### Create root logger with custom configuration
+
+```js
+const logger = require('ackee-node-logger)({
+    disableFields: ['error.stack'],
+    enableFields: ['req.protocol']
+});
+```
+
+Note: If you want to specify custom configuration it must be done **in the first require** of `ackee-node-logger`. 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.
+
+```js
+const databaseLogger = require('ackee-node-logger')('database')
+```
+
+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
+
+```js
+pino.info('hello world')
+pino.error('this is at error level')
+pino.info('the answer is %d', 42)
+pino.info({ obj: 42 }, 'hello world')
+pino.info({ obj: 42, b: 2 }, 'hello world')
+pino.info({ obj: { aa: 'bbb' } }, 'another')
+```
+
+All `pino` levels are supported and additionaly there is a `warning` level which is equivalent to `warn` level.
+
+Default minimal log level is `debug`.
+
+All loglevels up to warning (exclusive) - trace, debug and info - are logged to `stdout` **only**.
+
+All loglevels from warning up (inclusive) - warning, error, fatal - are logged to `stderr` **only**.
+
+## Express middleware
+
+`ackee-node-logger` contains an express middleware which you can use to log all requests and responses of your express application.
+
+Usage:
+```js
+const express = require('express');
+const logger = require('ackee-node-logger');
+
+const app = express();
+// or
+const router = express.Router();
+
+app.use(logger.express)
+// or
+router.use(logger.express)
+```
+
+By default, it will log all incoming requests in `debug` level, all outcoming responses with `out` property in `debug` level and all outcoming responses without `out` property on `info` level.
+
+If you use it together with logger's error express middleware, it will also log all errors in `error` level.
+
+```js
+app.use(logger.expressError)
+```
+
+All those log messages will contain request and possibly response, error, time from request to response and status code.
+
+## Environment-specific behavior
+`ackee-node-logger` is meant to be used throughout different environments (development, testing, production) and some of its configuration is setup differently based on the environment it runs in.
+
+### Testing
+If the `NODE_ENV` environment variable is set to `test`, all logs are turned off (minimal loglevel is set to `silent` which effectively turns logging off).
+
+### Production
+If the `NODE_ENV` environment variable is set to `production`, [standard pino log](https://github.com/pinojs/pino#usage) is used.
+
+### Otherwise
+In other cases, minimal loglevel is set to `debug` and [pino pretty human-readable logs](https://github.com/pinojs/pino/blob/master/docs/API.md#pretty) are used.
+
+## Options
+Options override both default logger configuration and environment-specific configuration. However, do not forget to specify it during the **first** `ackee-node-logger`. During it, root logger is created and it cannot be changed later.
+
+- `defaultLevel` - set logger's minimal loglevel (default is `debug`)
+- `disableFields` - list of paths which will be omitted from the objects being logged (if any)
+- `enableFields` - list of paths which will not be omitted by default serializers from objects being logged
+- `streams` - list of stream objects, which will be passed directly to [pino-multistream's multistream function](https://github.com/pinojs/pino-multi-stream#pinomsmultistreamstreams) instead of default `ackee-node-logger` stream
+
+## Default serializers
+`ackee-node-logger` defines some [pino serializers](https://github.com/pinojs/pino/blob/master/docs/API.md#constructor) on its own
+
+- `error` - logs `message`, `code`, `stack` and `data` fields
+- `processEnv` - logs `NODE_PATH` and `NODE_ENV`
+- `req` - logs `body`, `query`, `url`, `method` and omits `password` and `passwordCheck` from `body` and `query`
+- `res` - logs `out` and `time`

express.js

@@ -0,0 +1,35 @@
+const onFinished = require('on-finished');
+const onHeaders = require('on-headers');
+
+const expressMiddleware = function(req, response, next) {
+    this.debug({ req, ackId: req.ackId }, 'Request accepted');
+    req._startAt = process.hrtime();
+    onHeaders(response, () => {
+        response._startAt = process.hrtime();
+        const diffFromSeconds = (response._startAt[0] - req._startAt[0]) * 1e3;
+        const diffFromNanoseconds = (response._startAt[1] - req._startAt[1]) * 1e-6;
+        const ms = diffFromSeconds + diffFromNanoseconds;
+        response.time = ms.toFixed(3);
+    });
+    onFinished(response, (err, res) => {
+        const error = res[Symbol.for('error')];
+        if (error) {
+            this.error({ error, req, res, ackId: req.ackId }, 'Error handler at the end of app');
+        } else if (res.out) {
+            this.debug({ req, res, ackId: req.ackId }, `Standard output [${res.statusCode}]`);
+        } else {
+            this.info({ req, res, ackId: req.ackId }, `Standard output [${res.statusCode}]`);
+        }
+    });
+    next();
+};
+
+const expressErrorMiddleware = (error, req, res, next) => {
+    res[Symbol.for('error')] = error;
+    next(error);
+};
+
+module.exports = {
+    expressMiddleware,
+    expressErrorMiddleware,
+};

foo.js

@@ -1,14 +1,8 @@
-// https://gist.github.com/tothandras/bc06910063015b8891ff0fbb909c68c2
-// https://github.com/trentm/node-bunyan#levels
-// https://news.ycombinator.com/item?id=14209168
-// https://tools.ietf.org/html/rfc5424
-
 const _ = require('lodash');
 const pino = require('pino');
-const onFinished = require('on-finished');
-const onHeaders = require('on-headers');
 const multistream = require('pino-multi-stream').multistream;
 const serializers = require('./serializers');
+const { expressMiddleware, expressErrorMiddleware } = require('./express');
 
 const levels = {
     silent: Infinity,
@@ -20,9 +14,6 @@ const levels = {
     trace: 10,
 };
 
-// options.disableFields = ['error.stack'];
-// options.enableFields = ['req.protocol'];
-
 const maxLevelWrite = function(data) {
     let dest;
     let stream;
@@ -48,79 +39,14 @@ const maxLevelWrite = function(data) {
     }
 };
 
-const expressMiddleware = function(req, response, next) {
-    this.debug({ req, ackId: req.ackId }, 'Request accepted');
-    req._startAt = process.hrtime();
-    onHeaders(response, () => {
-        response._startAt = process.hrtime();
-        const diffFromSeconds = (response._startAt[0] - req._startAt[0]) * 1e3;
-        const diffFromNanoseconds = (response._startAt[1] - req._startAt[1]) * 1e-6;
-        const ms = diffFromSeconds + diffFromNanoseconds;
-        response.time = ms.toFixed(3);
-    });
-    onFinished(response, (err, res) => {
-        const error = res[Symbol.for('error')];
-        if (error) {
-            this.error({ error, req, res, ackId: req.ackId }, 'Error handler at the end of app');
-        } else if (res.out) {
-            this.debug({ req, res, ackId: req.ackId }, `Standard output [${res.statusCode}]`);
-        } else {
-            this.info({ req, res, ackId: req.ackId }, `Standard output [${res.statusCode}]`);
-        }
-    });
-    next();
-};
-
-const expressErrorMiddleware = (error, req, res, next) => {
-    res[Symbol.for('error')] = error;
-    next(error);
-};
-
 const defaultLogger = (options = {}) => {
     const pretty = pino.pretty();
     pretty.pipe(process.stdout);
     const prettyErr = pino.pretty();
     prettyErr.pipe(process.stderr);
 
-    if (options.disableFields) {
-        _.forEach(serializers, (value, key) => {
-            const matcher = new RegExp(`^${key}.(.*)`);
-            const affectedFields = [];
-            options.disableFields.forEach(field => {
-                field.replace(matcher, (match, p1) => {
-                    affectedFields.push(p1);
-                });
-            });
-
-            if (affectedFields.length > 0) {
-                const newSerializer = obj => {
-                    return _.omit(value(obj), affectedFields);
-                };
-                serializers[key] = newSerializer;
-            }
-        });
-    }
-
-    if (options.enableFields) {
-        _.forEach(serializers, (value, key) => {
-            const matcher = new RegExp(`^${key}.(.*)`);
-            const affectedFields = [];
-            options.enableFields.forEach(field => {
-                field.replace(matcher, (match, p1) => {
-                    affectedFields.push(p1);
-                });
-            });
-
-            if (affectedFields.length > 0) {
-                const newSerializer = obj => {
-                    const newFields = _.pick(obj, affectedFields);
-                    const originalResult = value(obj);
-                    return _.assign(originalResult, newFields);
-                };
-                serializers[key] = newSerializer;
-            }
-        });
-    }
+    serializers.disablePaths(options.disableFields);
+    serializers.enablePaths(options.enableFields);
 
     const isProduction = process.env.NODE_ENV === 'production';
     const isTesting = process.env.NODE_ENV === 'test';
@@ -152,7 +78,10 @@ const defaultLogger = (options = {}) => {
         streams = options.streams;
     }
 
-    const logger = pino({ level: defaultLevel, timestamp: false, base: {}, serializers }, multistream(streams));
+    const logger = pino(
+        { level: defaultLevel, timestamp: false, base: {}, serializers: serializers.serializers },
+        multistream(streams)
+    );
     logger.warning = logger.warn;
 
     // Add maxLevel support to pino-multi-stream

index.js

@@ -1,13 +1,6 @@
 const _ = require('lodash');
 
-/**
- * Gets full URL from express Req object
- * @param {Req} req
- * @return {!string}
- */
-const fullUrlFromReq = req => (req.get ? `${req.protocol}://${req.get('host')}${req.originalUrl}` : '');
-
-module.exports = {
+const serializers = {
     error(obj) {
         return {
             message: _.get(obj, 'message'),
@@ -45,7 +38,7 @@ module.exports = {
         return {
             body,
             query,
-            url: fullUrlFromReq(obj),
+            url: obj.originalUrl || obj.url,
             method: _.get(obj, 'method'),
         };
     },
@@ -56,3 +49,55 @@ module.exports = {
         };
     },
 };
+
+const disablePaths = paths => {
+    if (!paths || paths.length <= 0) {
+        return;
+    }
+    _.forEach(serializers, (value, key) => {
+        const matcher = new RegExp(`^${key}.(.*)`);
+        const affectedFields = [];
+        paths.forEach(field => {
+            field.replace(matcher, (match, p1) => {
+                affectedFields.push(p1);
+            });
+        });
+
+        if (affectedFields.length > 0) {
+            const newSerializer = obj => {
+                return _.omit(value(obj), affectedFields);
+            };
+            serializers[key] = newSerializer;
+        }
+    });
+};
+
+const enablePaths = paths => {
+    if (!paths || paths.length <= 0) {
+        return;
+    }
+    _.forEach(serializers, (value, key) => {
+        const matcher = new RegExp(`^${key}.(.*)`);
+        const affectedFields = [];
+        paths.forEach(field => {
+            field.replace(matcher, (match, p1) => {
+                affectedFields.push(p1);
+            });
+        });
+
+        if (affectedFields.length > 0) {
+            const newSerializer = obj => {
+                const newFields = _.pick(obj, affectedFields);
+                const originalResult = value(obj);
+                return _.assign(originalResult, newFields);
+            };
+            serializers[key] = newSerializer;
+        }
+    });
+};
+
+module.exports = {
+    serializers,
+    enablePaths,
+    disablePaths,
+};