Узел: войдите в файл вместо консоли

вы также можете просто перегрузить консоль по умолчанию.функция 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');
};

выше пример будет регистрироваться для отладки.журнал и stdout.

Edit: смотрите многопараметрическую версию Clément также на данной странице.

Если вы ищете что-то в производстве У. - пожалуй, лучший выбор.

Если вы просто хотите сделать dev вещи быстро, вывод непосредственно в файл (я думаю, что это работает только для * nix систем):

nohup node simple-server.js > output.log &

Я часто использую много аргументов

У. очень популярный npm-модуль, используемый для ведения журнала.

вот как это сделать.
Установите winston в свой проект как:

npm install winston --save

вот конфигурация, готовая к использованию из коробки, которую я часто использую в своих проектах в качестве регистратора.js под 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
};

а затем просто импортировать везде, где требуется, как это:

const errorLog = require('../util/logger').errorlog;
const successlog = require('../util/logger').successlog;

тогда вы можете зарегистрировать успех как:

successlog.info(`Success Message and variables: ${variable}`);

и ошибок как:

errorlog.error(`Error Message : ${error}`);

Он также регистрирует все успешные журналы и журналы ошибок в файле под каталогом журналов по дате, как вы можете видеть здесь.

Если это для приложения, вам, вероятно, лучше использовать модуль ведения журнала. Это даст вам больше гибкости. Несколько предложений.

• Уинстон https://github.com/indexzero/winston
• log4js https://github.com/nomiddlename/log4js-node

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;

чтобы использовать его, сделайте что-то вроде:

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;

чтобы избавить себя от необходимости писать файлы журналов, вращать и прочее, вы можете рассмотреть возможность использования простого модуля регистратора, такого как 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;

еще одно решение, которое еще не упомянуто, - это зацепить 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

для получения дополнительной информации, проверить этот суть.

прямо из документации по API на nodejs консоль

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

теперь вы можете использовать гусеницы который представляет собой систему регистрации на основе потоков, позволяющую вам войти в нее, а затем передать вывод в разные преобразования и местоположения.

вывод в файл так же просто, как:

var logger = new (require('./').Logger)();
logger.pipe(require('fs').createWriteStream('./debug.log'));
logger.log('your log message');

полный пример на Сайт Caterpillar

вы также можете взглянуть на этот модуль npm: https://www.npmjs.com/package/noogger

noogger

просто и прямо вперед...

Я взял на себя идею замены выходного потока на мой поток.

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;

улучшить Андрес Риофрио, чтобы обрабатывать любое количество аргументов

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');
};

Я просто построить пакет, чтобы сделать это, надеюсь, вам понравится ;) https://www.npmjs.com/package/writelog

Я для себя просто взял пример с Уинстона и добавил log(...) метод (потому что Уинстон называет его info(..):