22

✏️ Editing: PrettyStream.js

var moment = require('moment'),
    Transform = require('stream').Transform,
    format = require('util').format,
    prettyjson = require('prettyjson'),
    each = require('lodash/each'),
    omit = require('lodash/omit'),
    get = require('lodash/get'),
    isArray = require('lodash/isArray'),
    isEmpty = require('lodash/isEmpty'),
    isObject = require('lodash/isObject'),
    isString = require('lodash/isString'),
    _private = {
        levelFromName: {
            10: 'trace',
            20: 'debug',
            30: 'info',
            40: 'warn',
            50: 'error',
            60: 'fatal'
        },
        colorForLevel: {
            10: 'grey',
            20: 'grey',
            30: 'cyan',
            40: 'magenta',
            50: 'red',
            60: 'inverse'
        },
        colors: {
            'default': [39, 39],
            'bold': [1, 22],
            'italic': [3, 23],
            'underline': [4, 24],
            'inverse': [7, 27],
            'white': [37, 39],
            'grey': [90, 39],
            'black': [30, 39],
            'blue': [34, 39],
            'cyan': [36, 39],
            'green': [32, 39],
            'magenta': [35, 39],
            'red': [31, 39],
            'yellow': [33, 39]
        }
    };

function colorize(colors, value) {
    if (isArray(colors)) {
        return colors.reduce((acc, color) => colorize(color, acc), value);
    } else {
        return '\x1B[' + _private.colors[colors][0] + 'm' + value + '\x1B[' + _private.colors[colors][1] + 'm';
    }
}

function statusCode(status) {
    var color = status >= 500 ? 'red'
        : status >= 400 ? 'yellow'
        : status >= 300 ? 'cyan'
        : status >= 200 ? 'green'
        : 'default' // no color

return colorize(color, status);
}

class PrettyStream extends Transform {
    constructor(options) {
        options = options || {};
        super(options);

this.mode = options.mode || 'short';
    }

write(data, enc, cb) {
        // Bunyan sometimes passes things as objects. Because of this, we need to make sure
        // the data is converted to JSON
        if (isObject(data) && !(data instanceof Buffer)) {
            data = JSON.stringify(data);
        }

super.write(data, enc, cb);
    }

_transform(data, enc, cb) {
        if (!isString(data)) {
            data = data.toString();
        }

// Remove trailing newline if any
        data = data.replace(/\\n$/, '');

try {
            data = JSON.parse(data);
        } catch (err) {
            cb(err);
            // If data is not JSON we don't want to continue processing as if it is
            return;
        }

var output = '',
            time = moment(data.time).format('YYYY-MM-DD HH:mm:ss'),
            logLevel = _private.levelFromName[data.level].toUpperCase(),
            codes = _private.colors[_private.colorForLevel[data.level]],
            bodyPretty = '';

logLevel = '\x1B[' + codes[0] + 'm' + logLevel + '\x1B[' + codes[1] + 'm';

if (data.req) {
            output += format('[%s] %s "%s %s" %s %s\n',
                time,
                logLevel,
                data.req.method.toUpperCase(),
                get(data, 'req.originalUrl'),
                statusCode(get(data, 'res.statusCode')),
                get(data, 'res.responseTime')
            );
        }
        else if (data.msg === undefined) {
            output += format('[%s] %s\n',
                time,
                logLevel
            );
        }
        else {
            bodyPretty += data.msg;
            output += format('[%s] %s %s\n',
               time,
               logLevel,
               bodyPretty
            );
        }

each(omit(data, ['time', 'level', 'name', 'hostname', 'pid', 'v', 'msg']), function (value, key) {
            // we always output errors for now
            if (isObject(value) && value.message && value.stack) {
                var error = '\n';

if (value.errorType) {
                    error += colorize(_private.colorForLevel[data.level], 'Type: ' + value.errorType) + '\n';
                }

error += colorize(_private.colorForLevel[data.level], value.message) + '\n\n';

if (value.context) {
                    error += colorize('white', value.context) + '\n';
                }

if (value.help) {
                    error += colorize('yellow', value.help) + '\n';
                }

if (value.context || value.help) {
                    error += '\n';
                }

if (value.id) {
                    error += colorize(['white', 'bold'], 'Error ID:') + '\n';
                    error += '    ' + colorize('grey', value.id) + '\n\n';
                }

if (value.code) {
                    error += colorize(['white', 'bold'], 'Error Code: ') + '\n';
                    error += '    ' + colorize('grey', value.code) + '\n\n';
                }

if (value.errorDetails) {
                    let details = value.errorDetails;

try {
                        const jsonDetails = JSON.parse(value.errorDetails);
                        details = isArray(jsonDetails) ? jsonDetails[0] :jsonDetails;
                    } catch (err) {
                        // no need for special handling as we default to unparsed 'errorDetails'
                    }

const pretty = prettyjson.render(details, {
                        noColor: true
                    }, 4);

error += colorize(['white', 'bold'], 'Details:') + '\n';
                    error += colorize('grey', pretty) + '\n\n';
                }

if (value.stack && !value.hideStack) {
                    error += colorize('grey', '----------------------------------------') + '\n\n';
                    error += colorize('grey', value.stack) + '\n';
                }

output += format('%s\n', colorize(_private.colorForLevel[data.level], error));
            }
            else if (isObject(value)) {
                bodyPretty += '\n' + colorize('yellow', key.toUpperCase()) + '\n';

var sanitized = {};

each(value, function (innerValue, innerKey) {
                    if (!isEmpty(innerValue)) {
                        sanitized[innerKey] = innerValue;
                    }
                });

bodyPretty += prettyjson.render(sanitized, {}) + '\n';
            } else {
                bodyPretty += prettyjson.render(value, {}) + '\n';
            }
        });

if (this.mode !== 'short' && (bodyPretty !== data.msg)) {
            output += format('%s\n', colorize('grey', bodyPretty));
        }

cb(null, output);
    }
}

module.exports = PrettyStream;

MR SKB