节点通用日志记录，快速应用 - 最佳实践？ [英] Common logging for node, express application -- best practice?

问题描述

我正在使用一个具有几十个模块的node.js应用程序，并使用bunyan进行日志记录（JSON输出，多个可配置流）。我一直在寻找如何在所有模块中实现实例的很好的例子，但没有看到似乎是一个非常干净的例子，我可以从中学到。

下面说明了一种方法，但对我来说似乎很不实际（丑陋）。我是新来的节点& commonjs javascript一般，所以寻找有关如何改进它的建议。

模块：./lib/logger

  //加载配置文件（希望将其传递给构造函数）
 nconf.file（{file：fileConfig}）; 
 var logSetting = nconf.get（'log'）; 
 
 //实例化记录器
 var Bunyan = require（'bunyan'）; 
 var log = new Bunyan（{
 name：logSetting.name，
 streams：[
 {stream：process.stdout，
 level：logSetting.stdoutLevel}， 
 {path：logSetting.logfile 
 level：logSetting.logfileLevel} 
]，
 serializers：Bunyan.stdSerializers 
}）; 
 
函数Logger（）{
}; 
 
 Logger.prototype.info = function info（e）{log.info（e）}; 
 Logger.prototype.debug = function debug（e）{log.debug（e）}; 
 Logger.prototype.trace = function trace（e）{log.trace（e）}; 
 Logger.prototype.error = function error（e）{log.error（e）}; 
 Logger.prototype.warn = function warn（e）{log.warn（e）}; 
 
 module.exports = Logger; 
  

模块：主应用程序

  //创建记录器
 var logger = require（'./ lib / logger）
 var log = new logger（）; 
 
 //注意：想传递选项 - >新的记录器（选项）
 
 
模块：任何使用记录器的项目模块
 //打开记录器（新的，依靠单例...）
 var logger =要求（ './ LIB /记录器'）; 
 var log = new logger（）; 
  

或查看要点

任何建议？

编辑：

我修改了构造函数，使单例模式显式（而不是隐含）作为require行为的一部分。

  var log = null; 
函数Logger（option）{
 
 //使单例模式显式
 if（！Logger.log ）{
 Logger.log = this; 
} 
 return Logger.log; 
}; 
  

，然后更改初始化以获取选项参数

  //初始化记录器
 Logger.prototype.init = function init（options）{
 log = new Bunyan（{
 name：options.name，
 streams：[
 {stream： process.stdout，
 level：options.stdoutLevel}，
 {path：options.logfile，
级别：o ptions.logfileLevel} 
]，
 serializers：Bunyan.stdSerializers 
}）; 
}; 
  

解决方案

nodejs中的单例模式 - 是否需要？
实际上，在Node的环境中可能不需要单例。所有你需要做的是在一个单独的文件中创建一个记录器，说logger.js：

 
 var bunyan = require（bunyan ）; // Bunyan dependency 
 var logger = bunyan.createLogger（{name：myLogger}）; 
 
 module.exports = logger; 
 

然后，从另一个模块检索此记录器：

 
 var logger = require（./ logger）; 
 logger.info（任何你喜欢的）; 
 

I'm working on an node.js application with several dozen modules and using bunyan for logging (JSON output, multiple configurable streams). I've been looking for good examples of how to implement a instance across all the modules, but haven't seen what appears to be a really clean example I can learn from.

Below illustrates an approach that works, but seems quite inelegant (ugly) to me. I'm new to node & commonjs javascript in general, so looking for recommendations on how to improve it.

module: ./lib/logger

// load config file (would like this to be passed in to the constructor)
nconf.file({ file: fileConfig});
var logSetting = nconf.get('log');

// instantiate the logger
var Bunyan = require('bunyan');
var log = new Bunyan({
    name: logSetting.name,
streams : [
        { stream  : process.stdout, 
        level : logSetting.stdoutLevel},
        {    path : logSetting.logfile, 
            level : logSetting.logfileLevel}
    ],
serializers : Bunyan.stdSerializers
});

function Logger() {
};

Logger.prototype.info = function info(e) { log.info(e) };
Logger.prototype.debug = function debug(e) { log.debug(e) };
Logger.prototype.trace = function trace(e) { log.trace(e) };
Logger.prototype.error = function error(e) { log.error(e) };
Logger.prototype.warn = function warn(e) {  log.warn(e) };

module.exports = Logger;

module: main app

// create the logger
var logger = require('./lib/logger)
var log = new logger();

// note: would like to pass in options -->  new logger(options)


module: any project module using logger
// open the logger (new, rely on singleton...)
var logger = require('./lib/logger');
var log = new logger();

or view the gist

any recommendations?

EDIT:

I've modified the constructor, making the singleton pattern explicit (rather than implicit as part of the 'require' behaviour.

var log = null;
function Logger(option) {

// make the singleton pattern explicit
if (!Logger.log) {
    Logger.log = this;
}
    return Logger.log;
};  

and then changed the initialization to take an options parameter

// initialize the logger 
Logger.prototype.init = function init(options) {
log = new Bunyan({
    name: options.name,
    streams : [
        { stream  : process.stdout, 
            level : options.stdoutLevel},
        {    path : options.logfile, 
            level : options.logfileLevel}
    ],
    serializers : Bunyan.stdSerializers     
    });
};

解决方案

Singleton pattern in nodejs - is it needed? Actually, singleton is perhaps not needed in Node's environment. All you need to do is to create a logger in a separate file say, logger.js:

var bunyan = require("bunyan"); // Bunyan dependency
var logger = bunyan.createLogger({name: "myLogger"});

module.exports = logger;

Then, retrieve this logger from another module:

var logger = require("./logger");
logger.info("Anything you like");

这篇关于节点通用日志记录，快速应用 - 最佳实践？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！