Nœud: connectez-vous dans un fichier au lieu de la console

Puis-je configurer console.logpour que les journaux soient écrits sur un fichier au lieu d'être imprimés dans la console?

Mise à jour 2013 - Ceci a été écrit autour de Node v0.2 et v0.4; Il existe maintenant de bien meilleurs utilitaires pour la journalisation. Je recommande vivement Winston

Mise à jour fin 2013 - Nous utilisons toujours winston, mais maintenant avec une bibliothèque de journalisation pour envelopper la fonctionnalité autour de la journalisation des objets personnalisés et du formatage. Voici un échantillon de notre logger.js https://gist.github.com/rtgibbons/7354879

Cela devrait être aussi simple que cela.

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

Vous pouvez également simplement surcharger la fonction console.log par défaut:

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

L'exemple ci-dessus se connectera à debug.log et stdout.

Edit: Voir la version multiparamètre de Clément également sur cette page.

Si vous cherchez quelque chose en production, winston est probablement le meilleur choix.

Si vous voulez juste faire des choses de développement rapidement, sortez directement dans un fichier (je pense que cela ne fonctionne que pour les systèmes * nix):

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

J'utilise souvent de nombreux arguments pour console.log () et console.error () , donc ma solution serait:

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 est un module npm très populaire utilisé pour la journalisation.

Voici un guide pratique.
Installez winston dans votre projet en tant que:

npm install winston --save

Voici une configuration prête à l'emploi prête à l'emploi que j'utilise fréquemment dans mes projets comme logger.js sous 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
};

Et puis importez simplement là où c'est nécessaire comme ceci:

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

Ensuite, vous pouvez enregistrer le succès comme:

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

et erreurs comme:

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

Il enregistre également tous les journaux de succès et les journaux d'erreurs dans un fichier sous le répertoire des journaux par date, comme vous pouvez le voir ici.

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;

Pour l'utiliser, faites quelque chose comme:

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

S'il s'agit d'une application, il vaut probablement mieux utiliser un module de journalisation. Cela vous donnera plus de flexibilité. Quelques suggestions.

• winston https://github.com/indexzero/winston
• log4js https://github.com/nomiddlename/log4js-node

Une autre solution non encore mentionnée consiste à accrocher les Writableflux dans process.stdoutet process.stderr. De cette façon, vous n'avez pas besoin de remplacer toutes les fonctions de la console qui sortent vers stdout et stderr. Cette implémentation redirige à la fois stdout et stderr vers un fichier journal:

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

Il devrait s'imprimer dans la console

a
b
c
d
e
f

et dans le fichier journal:

c
d

Pour plus d'informations, consultez l' essentiel .

Pour les cas simples, nous pourrions rediriger les flux de sortie standard (STDOUT) et d'erreur standard (STDERR) directement vers un fichier par '>' et '2> & 1'

Exemple:

// test.js
(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");
})();

nœud test.js> test.log 2> & 1

Conformément à la norme POSIX, les flux «entrée», «sortie» et «erreur» sont identifiés par les descripteurs de fichier entiers positifs (0, 1, 2). c'est-à-dire que stdin vaut 0, stdout vaut 1 et stderr vaut 2.

'2> & 1' redirigera de 2 (stderr) vers 1 (stdout)

'>' redirigera de 1 (stdout) vers le fichier (test.log)

Écraser console.log est la voie à suivre. Mais pour qu'il fonctionne dans les modules requis, vous devez également l'exporter.

module.exports = console;

Pour vous éviter d'écrire des fichiers journaux, de les faire pivoter et d'autres choses, vous pouvez envisager d'utiliser un simple module de journalisation comme 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;

MÉTHODE STDOUT ET STDERR

Cette approche peut vous aider (j'utilise quelque chose de similaire dans mes projets) et fonctionne pour toutes les méthodes, y compris console.log, console.warn, console.error, console.info

Cette méthode écrit les octets écrits dans stdout et stderr dans un fichier. C'est mieux que de changer les méthodes console.log, console.warn, console.error, console.info, car la sortie sera exactement la même que celle de cette méthode

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)

Directement à partir de la documentation de l'API de nodejs sur la console

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

Vous pouvez désormais utiliser Caterpillar, un système de journalisation basé sur les flux, vous permettant de vous y connecter, puis de diriger la sortie vers différents transformations et emplacements.

La sortie vers un fichier est aussi simple que:

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

Exemple complet sur le site Web de Caterpillar

Vous pouvez également consulter ce module npm: https://www.npmjs.com/package/noogger

noogger

simple et direct ...

J'ai pris l'idée d'échanger le flux de sortie vers un flux mon.

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;

Améliorer sur Andres Riofrio, pour gérer n'importe quel nombre d'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');
};

Je viens de créer un pack pour ce faire, j'espère que vous l'aimerez;) https://www.npmjs.com/package/writelog

Pour ma part, j'ai simplement pris l'exemple de winston et ajouté la log(...)méthode (car winston le nomme 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;

Ensuite, utilisez simplement dans votre code:

const console = require('Console')

Maintenant, vous pouvez simplement utiliser les fonctions normales de journal dans votre fichier et il créera un fichier ET le consignera sur votre console (pendant le débogage / développement). À cause de if (process.env.NODE_ENV !== 'production') {(au cas où vous le voudriez également en production) ...