'use strict';
|
|
const os = require('os');
|
const util = require('util');
|
const chalk = require('chalk');
|
const utility = require('utility');
|
const iconv = require('iconv-lite');
|
const levels = require('./level');
|
const circularJSON = require('circular-json-for-egg');
|
const { FrameworkBaseError, FrameworkErrorFormater } = require('egg-errors');
|
|
const hostname = os.hostname();
|
const duartionRegexp = /([0-9]+ms)/g;
|
// eslint-disable-next-line no-useless-escape
|
const categoryRegexp = /(\[[\w\-_.:]+\])/g;
|
const httpMethodRegexp = /(GET|POST|PUT|PATH|HEAD|DELETE) /g;
|
|
/**
|
* @class LoggerUtils
|
*/
|
module.exports = {
|
normalizeLevel(level) {
|
if (typeof level === 'number') {
|
return level;
|
}
|
|
// 'WARN' => level.warn
|
if (typeof level === 'string' && level) {
|
return levels[level.toUpperCase()];
|
}
|
},
|
|
// default format
|
defaultFormatter(meta) {
|
return meta.date + ' ' + meta.level + ' ' + meta.pid + ' ' + meta.message;
|
},
|
|
// output to Terminal format
|
consoleFormatter(meta) {
|
let msg = meta.date + ' ' + meta.level + ' ' + meta.pid + ' ' + meta.message;
|
if (!chalk.supportsColor) {
|
return msg;
|
}
|
|
if (meta.level === 'ERROR') {
|
return chalk.red(msg);
|
} else if (meta.level === 'WARN') {
|
return chalk.yellow(msg);
|
}
|
|
msg = msg.replace(duartionRegexp, chalk.green('$1'));
|
msg = msg.replace(categoryRegexp, chalk.blue('$1'));
|
msg = msg.replace(httpMethodRegexp, chalk.cyan('$1 '));
|
return msg;
|
},
|
|
/**
|
* Get final formated log string buffer
|
*
|
* Invoke link: {@Link Logger#log} -> {@link Transport#log} -> LoggerUtils.format
|
* @function LoggerUtils#format
|
* @param {String} level - log level
|
* @param {Array} args - format arguments
|
* @param {Object} meta - loging behaviour meta infomation
|
* - {String} level
|
* - {Boolean} raw
|
* - {Function} formatter
|
* - {Error} error
|
* - {String} message
|
* - {Number} pid
|
* - {String} hostname
|
* - {String} date
|
* @param {Object} options - {@link Transport}'s options
|
* - {String} encoding
|
* - {Boolean} json
|
* - {Function} formatter
|
* @return {String|Buffer} formatted log string buffer
|
*/
|
format(level, args, meta, options) {
|
meta = meta || {};
|
let message;
|
let output;
|
let formatter = meta.formatter || options.formatter;
|
if (meta.ctx && options.contextFormatter) formatter = options.contextFormatter;
|
|
if (args[0] instanceof Error) {
|
message = formatError(args[0]);
|
} else {
|
message = util.format.apply(util, args);
|
}
|
|
if (meta.raw === true) {
|
output = message;
|
} else if (options.json === true || formatter) {
|
meta.level = level;
|
meta.date = utility.logDate(',');
|
meta.pid = process.pid;
|
meta.hostname = hostname;
|
meta.message = message;
|
if (options.json === true) {
|
const outputMeta = { ...meta };
|
outputMeta.ctx = undefined;
|
output = JSON.stringify(outputMeta);
|
} else {
|
output = formatter(meta);
|
}
|
} else {
|
output = message;
|
}
|
|
if (!output) return Buffer.from('');
|
|
output += options.eol;
|
|
// convert string to buffer when encoding is not utf8
|
return options.encoding === 'utf8' ? output : iconv.encode(output, options.encoding);
|
},
|
|
// Like `Object.assign`, but don't copy `undefined` value
|
assign(target) {
|
if (!target) {
|
return {};
|
}
|
const sources = Array.prototype.slice.call(arguments, 1);
|
for (let i = 0; i < sources.length; i++) {
|
const source = sources[i];
|
if (!source) continue;
|
const keys = Object.keys(source);
|
for (let j = 0; j < keys.length; j++) {
|
const key = keys[j];
|
if (source[key] !== undefined && source[key] !== null) {
|
target[key] = source[key];
|
}
|
}
|
}
|
return target;
|
},
|
|
formatError,
|
};
|
|
function formatError(err) {
|
if (FrameworkBaseError.isFrameworkError(err)) {
|
return FrameworkErrorFormater.format(err);
|
}
|
|
if (err.name === 'Error' && typeof err.code === 'string') {
|
err.name = err.code + err.name;
|
}
|
|
if (err.host) {
|
err.message += ` (${err.host})`;
|
}
|
|
// name and stack could not be change on node 0.11+
|
const errStack = err.stack || 'no_stack';
|
const errProperties = Object.keys(err).map(key => inspect(key, err[key])).join('\n');
|
return util.format('nodejs.%s: %s\n%s\n%s\npid: %s\nhostname: %s\n',
|
err.name,
|
err.message,
|
errStack.substring(errStack.indexOf('\n') + 1),
|
errProperties,
|
process.pid,
|
hostname
|
);
|
}
|
|
function inspect(key, value) {
|
return `${key}: ${formatObject(value)}`;
|
}
|
|
function formatString(str) {
|
if (str.length > 10000) {
|
return `${str.substr(0, 10000)}...(${str.length})`;
|
}
|
return str;
|
}
|
|
function formatBuffer(buf) {
|
const tail = buf.data.length > 50 ? ` ...(${buf.data.length}) ` : '';
|
const bufStr = buf.data.slice(0, 50).map(i => {
|
i = i.toString(16);
|
if (i.length === 1) i = `0${i}`;
|
return i;
|
}).join(' ');
|
return `<Buffer ${bufStr}${tail}>`;
|
}
|
|
function formatObject(obj) {
|
try {
|
return circularJSON.stringify(obj, (key, v) => {
|
if (typeof v === 'string') return formatString(v);
|
if (v && v.type === 'Buffer' && Array.isArray(v.data)) {
|
return formatBuffer(v);
|
}
|
if (v instanceof RegExp) return util.inspect(v);
|
return v;
|
});
|
} catch (_) {
|
/* istanbul ignore next */
|
return String(obj);
|
}
|
}
|
