Nó: registar num ficheiro em vez da consola
Posso configurar console.log
para que os registos sejam escritos num ficheiro em vez de serem impressos na consola?
16 answers
Actualizar 2013 - isto foi escrito em torno do nó v0. 2 e v0. 4; existem muito melhores utilites agora em torno do registro. Recomendo vivamente o Winston.
Actualizar tarde 2013 - ainda usamos winston, mas agora com uma biblioteca de logger para envolver a funcionalidade em torno do registro de objetos personalizados e formatação. Aqui está uma amostra do nosso lenhador.js https://gist.github.com/rtgibbons/7354879
Deve ser tão simples como isto.
var access = fs.createWriteStream(dir + '/node.access.log', { flags: 'a' })
, error = fs.createWriteStream(dir + '/node.error.log', { flags: 'a' });
// redirect stdout / stderr
proc.stdout.pipe(access);
proc.stderr.pipe(error);
Também pode sobrecarregar a consola por omissão.função de Registo:
var fs = require('fs');
var util = require('util');
var log_file = fs.createWriteStream(__dirname + '/debug.log', {flags : 'w'});
var log_stdout = process.stdout;
console.log = function(d) { //
log_file.write(util.format(d) + '\n');
log_stdout.write(util.format(d) + '\n');
};
O exemplo acima irá ligar-se à depuração.log e stdout.
Editar: Veja a versão multiparâmetro por Clément também nesta página.
Se você está procurando algo em produçãowinston é provavelmente a melhor escolha.
Se só quiser fazer as coisas do dev rapidamente, envie directamente para um ficheiro (penso que isto só funciona para os sistemas * nix):
nohup node simple-server.js > output.log &
Uso muitas vezes muitos argumentos para a consola .consola log() e .erro () , por isso a minha solução seria:
var fs = require('fs');
var util = require('util');
var logFile = fs.createWriteStream('log.txt', { flags: 'a' });
// Or 'w' to truncate the file every time the process starts.
var logStdout = process.stdout;
console.log = function () {
logFile.write(util.format.apply(null, arguments) + '\n');
logStdout.write(util.format.apply(null, arguments) + '\n');
}
console.error = console.log;
O Winston é um módulo npm muito popular usado para registar.
Aqui está um how-to.Instalar o winston no seu projecto como:
npm install winston --save
Aqui está uma configuração pronta para usar fora de caixa que eu uso frequentemente em meus projetos como logger.js under utils.
/**
* Configurations of logger.
*/
const winston = require('winston');
const winstonRotator = require('winston-daily-rotate-file');
const consoleConfig = [
new winston.transports.Console({
'colorize': true
})
];
const createLogger = new winston.Logger({
'transports': consoleConfig
});
const successLogger = createLogger;
successLogger.add(winstonRotator, {
'name': 'access-file',
'level': 'info',
'filename': './logs/access.log',
'json': false,
'datePattern': 'yyyy-MM-dd-',
'prepend': true
});
const errorLogger = createLogger;
errorLogger.add(winstonRotator, {
'name': 'error-file',
'level': 'error',
'filename': './logs/error.log',
'json': false,
'datePattern': 'yyyy-MM-dd-',
'prepend': true
});
module.exports = {
'successlog': successLogger,
'errorlog': errorLogger
};
E depois simplesmente importar onde for necessário como este:
const errorLog = require('../util/logger').errorlog;
const successlog = require('../util/logger').successlog;
Então você pode registar o sucesso como:
successlog.info(`Success Message and variables: ${variable}`);
E erros como:
errorlog.error(`Error Message : ${error}`);
Também regista todos os registos de sucesso e de erros. num ficheiro sob a data do directório de registos, como pode ver aqui.Se isto é para uma aplicação, provavelmente é melhor usar um módulo de Registo. Vai dar-te mais flexibilidade. Sugestao.
const fs = require("fs");
const keys = Object.keys;
const Console = console.Console;
/**
* Redirect console to a file. Call without path or with false-y
* value to restore original behavior.
* @param {string} [path]
*/
function file(path) {
const con = path ? new Console(fs.createWriteStream(path)) : null;
keys(Console.prototype).forEach(key => {
if (path) {
this[key] = function() {
con[key].apply(con, arguments);
};
} else {
delete this[key];
}
});
};
// patch global console object and export
module.exports = console.file = file;
Para usá - lo, faça algo como:
require("./console-file");
console.file("/path/to.log");
console.log("write to file!");
console.error("also write to file!");
console.file(); // go back to writing to stdout
module.exports = console;
Para se poupar ao trabalho de escrever ficheiros de Registo, rotação e outras coisas, pode considerar usar um módulo simples de registo como o winston:
// Include the logger module
var winston = require('winston');
// Set up log file. (you can also define size, rotation etc.)
winston.add(winston.transports.File, { filename: 'somefile.log' });
// Overwrite some of the build-in console functions
console.error=winston.error;
console.log=winston.info;
console.info=winston.info;
console.debug=winston.debug;
console.warn=winston.warn;
module.exports = console;
Outra solução que ainda não foi mencionada é ligar os riachos Writable
em process.stdout
e process.stderr
. Desta forma, não precisa de anular todas as funções da consola {[[9]} que produzem para o stdout e o stderr. Esta implementação redirecciona tanto o stdout como o stderr para um ficheiro de Registo:
var log_file = require('fs').createWriteStream(__dirname + '/log.txt', {flags : 'w'})
function hook_stream(stream, callback) {
var old_write = stream.write
stream.write = (function(write) {
return function(string, encoding, fd) {
write.apply(stream, arguments) // comments this line if you don't want output in the console
callback(string, encoding, fd)
}
})(stream.write)
return function() {
stream.write = old_write
}
}
console.log('a')
console.error('b')
var unhook_stdout = hook_stream(process.stdout, function(string, encoding, fd) {
log_file.write(string, encoding)
})
var unhook_stderr = hook_stream(process.stderr, function(string, encoding, fd) {
log_file.write(string, encoding)
})
console.log('c')
console.error('d')
unhook_stdout()
unhook_stderr()
console.log('e')
console.error('f')
Deve ser impressa na consola
a
b
c
d
e
f
E no ficheiro de Registo:
c
d
Para mais informações, verifique este gist .
const output = fs.createWriteStream('./stdout.log');
const errorOutput = fs.createWriteStream('./stderr.log');
// custom simple logger
const logger = new Console(output, errorOutput);
// use it like console
const count = 5;
logger.log('count: %d', count);
// in stdout.log: count 5
Você pode agora usar Caterpillar que é um sistema de Registo baseado em fluxos, permitindo-lhe ligar-se a ele, em seguida, encaminhar a saída para diferentes transformações e locais.
A saída para um ficheiro é tão fácil como:
var logger = new (require('./').Logger)();
logger.pipe(require('fs').createWriteStream('./debug.log'));
logger.log('your log message');
Você também pode dar uma olhada neste módulo npm: https://www.npmjs.com/package/noogger
Simples e em frente...const LogLater = require ('./loglater.js');
var logfile=new LogLater( 'log'+( new Date().toISOString().replace(/[^a-zA-Z0-9]/g,'-') )+'.txt' );
var PassThrough = require('stream').PassThrough;
var myout= new PassThrough();
var wasout=console._stdout;
myout.on('data',(data)=>{logfile.dateline("\r\n"+data);wasout.write(data);});
console._stdout=myout;
var myerr= new PassThrough();
var waserr=console._stderr;
myerr.on('data',(data)=>{logfile.dateline("\r\n"+data);waserr.write(data);});
console._stderr=myerr;
Loglater.js:
const fs = require('fs');
function LogLater(filename, noduplicates, interval) {
this.filename = filename || "loglater.txt";
this.arr = [];
this.timeout = false;
this.interval = interval || 1000;
this.noduplicates = noduplicates || true;
this.onsavetimeout_bind = this.onsavetimeout.bind(this);
this.lasttext = "";
process.on('exit',()=>{ if(this.timeout)clearTimeout(this.timeout);this.timeout=false; this.save(); })
}
LogLater.prototype = {
_log: function _log(text) {
this.arr.push(text);
if (!this.timeout) this.timeout = setTimeout(this.onsavetimeout_bind, this.interval);
},
text: function log(text, loglastline) {
if (this.noduplicates) {
if (this.lasttext === text) return;
this.lastline = text;
}
this._log(text);
},
line: function log(text, loglastline) {
if (this.noduplicates) {
if (this.lasttext === text) return;
this.lastline = text;
}
this._log(text + '\r\n');
},
dateline: function dateline(text) {
if (this.noduplicates) {
if (this.lasttext === text) return;
this.lastline = text;
}
this._log(((new Date()).toISOString()) + '\t' + text + '\r\n');
},
onsavetimeout: function onsavetimeout() {
this.timeout = false;
this.save();
},
save: function save() { fs.appendFile(this.filename, this.arr.splice(0, this.arr.length).join(''), function(err) { if (err) console.log(err.stack) }); }
}
module.exports = LogLater;
Melhorar Andres Riofrio, para lidar com qualquer número de argumentos
var fs = require('fs');
var util = require('util');
var log_file = fs.createWriteStream(__dirname + '/debug.log', {flags : 'w'});
var log_stdout = process.stdout;
console.log = function(...args) {
var output = args.join(' ');
log_file.write(util.format(output) + '\r\n');
log_stdout.write(util.format(output) + '\r\n');
};
info(..)
:
Consola.js:
"use strict"
// Include the logger module
const winston = require('winston');
const logger = winston.createLogger({
level: 'info',
format: winston.format.json(),
transports: [
//
// - Write to all logs with level `info` and below to `combined.log`
// - Write all logs error (and below) to `error.log`.
//
new winston.transports.File({ filename: 'error.log', level: 'error' }),
new winston.transports.File({ filename: 'combined.log' })
]
});
//
// If we're not in production then log to the `console` with the format:
// `${info.level}: ${info.message} JSON.stringify({ ...rest }) `
//
if (process.env.NODE_ENV !== 'production') {
logger.add(new winston.transports.Console({
format: winston.format.simple()
}));
}
// Add log command
logger.log=logger.info;
module.exports = logger;
Então basta usar no seu código:
const console = require('Console')
Agora você pode simplesmente usar as funções de Registo normais no seu ficheiro e ele irá criar um ficheiro e registá-lo na sua consola (enquanto depuração/desenvolvimento). Por causa de if (process.env.NODE_ENV !== 'production') {
(no caso de querê-lo também em produção)...