노드 : 콘솔 대신 파일에 로그인
console.log콘솔에서 인쇄하는 대신 파일에 로그를 쓰도록 구성 할 수 있습니까 ?
업데이트 2013- 이것은 노드 v0.2 및 v0.4를 중심으로 작성되었습니다. 로깅과 관련하여 훨씬 더 유용한 유틸리티가 있습니다. 나는 윈스턴을 강력히 추천한다
Late 2013 업데이트- 우리는 여전히 winston을 사용하지만 이제는 로거 라이브러리와 함께 사용자 지정 개체 로깅 및 서식 지정 기능을 래핑합니다. 다음은 logger.js의 샘플입니다 https://gist.github.com/rtgibbons/7354879
이만큼 간단해야합니다.
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);
기본 console.log 함수를 오버로드 할 수도 있습니다.
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');
};
위의 예제는 debug.log 및 stdout에 기록됩니다.
편집 : 이 페이지에서도 Clément의 멀티 파라미터 버전을 참조하십시오.
프로덕션 환경에서 무언가를 찾고 있다면 윈스턴 이 최선의 선택 일 것입니다.
개발 작업을 빨리하고 싶다면 파일로 직접 출력하십시오 (* nix 시스템에서만 작동한다고 생각합니다).
nohup node simple-server.js > output.log &
나는 종종 console.log () 및 console.error ()에 많은 인수를 사용 하므로 솔루션은 다음과 같습니다.
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;
Winston 은 로깅에 사용되는 매우 인기있는 npm 모듈입니다.
방법은 다음과 같습니다.
다음과 같이 프로젝트에 winston을 설치하십시오.
npm install winston --save
다음은 utils에서 logger.js로 프로젝트에서 자주 사용하는 기본 구성을 사용할 준비가 된 것입니다.
/**
* 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
};
그런 다음 필요한 위치를 다음과 같이 간단히 가져 오십시오.
const errorLog = require('../util/logger').errorlog;
const successlog = require('../util/logger').successlog;
그런 다음 성공을 다음과 같이 기록 할 수 있습니다.
successlog.info(`Success Message and variables: ${variable}`);
및 오류 :
errorlog.error(`Error Message : ${error}`);
또한 여기에서 볼 수 있듯이 모든 성공 로그 및 오류 로그를 로그 디렉토리 아래의 파일에 날짜별로 기록합니다.
const fs = require("fs");
const {keys} = Object;
const {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] = (...args) => con[key](...args);
} else {
delete this[key];
}
});
};
// patch global console object and export
module.exports = console.file = file;
그것을 사용하려면 다음과 같이하십시오.
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
이것이 응용 프로그램을위한 것이라면 로깅 모듈을 사용하는 것이 좋습니다. 더 많은 유연성을 제공합니다. 몇 가지 제안.
아직 언급되지 않은 또 다른 해결책은 후크입니다 Writable에 스트림을 process.stdout하고 process.stderr. 이 방법 으로 stdout 및 stderr로 출력되는 모든 콘솔 기능 을 대체 할 필요는 없습니다 . 이 구현은 stdout과 stderr을 모두 로그 파일로 리디렉션합니다.
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')
콘솔에서 인쇄해야합니다
a
b
c
d
e
f
그리고 로그 파일에서 :
c
d
자세한 내용은이 요점을 확인하십시오 .
방법 STDOUT 및 STDERR
이 접근법은 도움이 될 수 있으며 (내 프로젝트에서 비슷한 것을 사용함) console.log, console.warn, console.error, console.info를 포함한 모든 메소드에서 작동합니다.
이 메소드는 stdout 및 stderr로 작성된 바이트를 파일에 씁니다. 출력은이 메소드 출력과 정확히 동일하므로 console.log, console.warn, console.error, console.info 메소드를 변경하는 것보다 낫습니다.
var fs= require("fs")
var os= require("os")
var HOME= os.homedir()
var stdout_r = fs.createWriteStream(HOME + '/node.stdout.log', { flags: 'a' })
var stderr_r = fs.createWriteStream(HOME + '/node.stderr.log', { flags: 'a' })
var attachToLog= function(std, std_new){
var originalwrite= std.write
std.write= function(data,enc){
try{
var d= data
if(!Buffer.isBuffer(d))
d= Buffer.from(data, (typeof enc === 'string') ? enc : "utf8")
std_new.write.apply(std_new, d)
}catch(e){}
return originalwrite.apply(std, arguments)
}
}
attachToLog(process.stdout, stdout_r)
attachToLog(process.stderr, stderr_r)
// recommended catch error on stdout_r and stderr_r
// stdout_r.on("error", yourfunction)
// stderr_r.on("error", yourfunction)
console.log를 덮어 쓰는 방법입니다. 그러나 필요한 모듈에서 작동하려면 내 보내야합니다.
module.exports = console;
로그 파일 작성, 회전 및 작업 문제를 해결하려면 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;
콘솔 의 nodejs API 문서에서 직접
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
간단한 경우, 표준 출력 (STDOUT) 및 표준 오류 (STDERR) 스트림을 > 및 2> & 1 로 파일로 직접 리디렉션 할 수 있습니다.
예:
(function() {
// Below outputs are sent to Standard Out (STDOUT) stream
console.log("Hello Log");
console.info("Hello Info");
// Below outputs are sent to Standard Error (STDERR) stream
console.error("Hello Error");
console.warn("Hello Warning");
})();
node test.js> test.log 2> & 1
POSIX 표준에 따라 '입력', '출력'및 '오류' 스트림은 양의 정수 파일 디스크립터 (0, 1, 2) 로 식별됩니다 . 즉, stdin은 0, stdout은 1, stderr은 2입니다.
'2> & 1'은 2 (stderr)를 1 (stdout)로 리디렉션합니다.
'>'는 1 (stdout)을 파일로 리디렉션합니다
이제 스트림 기반 로깅 시스템 인 Caterpillar 를 사용 하여 로그를 기록한 다음 다른 변환 및 위치로 출력을 파이프 할 수 있습니다.
파일로 출력하는 것은 다음과 같이 쉽습니다.
var logger = new (require('./').Logger)();
logger.pipe(require('fs').createWriteStream('./debug.log'));
logger.log('your log message');
Complete example on the Caterpillar Website
You can also have a look at this npm module: https://www.npmjs.com/package/noogger
simple and straight forward...
I took on the idea of swapping the output stream to a my stream.
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;
Improve on Andres Riofrio , to handle any number of arguments
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');
};
I just build a pack to do this, hope you like it ;) https://www.npmjs.com/package/writelog
I for myself simply took the example from winston and added the log(...) method (because winston names it info(..):
Console.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;
Then simply use in your code:
const console = require('Console')
Now you can simply use the normal log functions in your file and it will create a file AND log it to your console (while debugging/developing). Because of if (process.env.NODE_ENV !== 'production') { (in case you want it also in production)...
참고 URL : https://stackoverflow.com/questions/8393636/node-log-in-a-file-instead-of-the-console
'Programing' 카테고리의 다른 글
| 왜 파이썬 3에서 부동 소수점 값 4 * 0.1이 멋지게 보이지만 3 * 0.1은 그렇지 않습니까? (0) | 2020.06.09 |
|---|---|
| Spring에서 Tomcat이 제공하는 JNDI DataSource를 사용하는 방법은 무엇입니까? (0) | 2020.06.09 |
| 힘내 하위 모듈 추가 : "git 디렉토리가 로컬에서 발견되었습니다"문제 (0) | 2020.06.09 |
| PowerShell에서 MD5 체크섬을 얻는 방법 (0) | 2020.06.09 |
| NameError를주는 모듈을 다시로드하는 중 : 이름 'reload'가 정의되지 않았습니다. (0) | 2020.06.09 |