Configure Node.js to log to a file instead of the console

You could also just overload the default console.log function:

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

Above example will log to debug.log and stdout.

Edit: See multiparameter version by Clément also on this page.

If you are looking for something in production winston is probably the best choice.

If you just want to do dev stuff quickly, output directly to a file (I think this works only for *nix systems):

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

I often use many arguments to console.log() and console.error(), so my solution would be:

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 is a very-popular npm-module used for logging.

Here is a how-to.
Install winston in your project as:

npm install winston --save 

Here's a configuration ready to use out-of-box that I use frequently in my projects as 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 }; 

And then simply import wherever required as this:

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

Then you can log the success as:

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

and Errors as:

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

It also logs all the success-logs and error-logs in a file under logs directory date-wise as you can see here.

For simple cases, we could redirect the Standard Out (STDOUT) and Standard Error (STDERR) streams directly to a file(say, test.log) using '>' and '2>&1'

Example:

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

node test.js > test.log 2>&1

As per the POSIX standard, 'input', 'output' and 'error' streams are identified by the positive integer file descriptors (0, 1, 2). i.e., stdin is 0, stdout is 1, and stderr is 2.

Step 1: '2>&1' will redirect from 2 (stderr) to 1 (stdout)

Step 2: '>' will redirect from 1 (stdout) to file (test.log)

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; 

To use it, do something like:

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 

If you're using linux, you can also use output redirection. Not sure about Windows.

node server.js >> file.log 2>> file.log 

>> file.log to redirect stdout to the file

2>> file.log to redirect stderr to the file

others use the shorthand &>> for both stdout and stderr but it's not accepted by both my mac and ubuntu :(

extra: > overwrites, while >> appends.

By the way, regarding NodeJS loggers, I use pino + pino-pretty logger

If this is for an application, you're probably better off using a logging module. It'll give you more flexibility. Some suggestions.

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

Straight from nodejs's API docs on 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 

Another solution not mentioned yet is by hooking the Writable streams in process.stdout and process.stderr. This way you don't need to override all the console functions that output to stdout and stderr. This implementation redirects both stdout and stderr to a log file:

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

It should print in the console

a b c d e f 

and in the log file:

c d 

For more info, check this gist.

You can use the nodejs Console constructor

const mylog = new console.Console( fs.createWriteStream("log/logger.log"), fs.createWriteStream("log/error.log") ); 

And then you can use it just like the normal console class, eg:

mylog.log("Ok!"); // Will be written into 'log/logger.log' mylog.error("Bad!"); // Will be written into 'log/error.log' 

Overwriting console.log is the way to go. But for it to work in required modules, you also need to export it.

module.exports = console; 

To save yourself the trouble of writing log files, rotating and stuff, you might consider using a simple logger module like 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; 

Most logger is overkill and does not support the build in console.log correctly. Hence I create console-log-to-file:

import { consoleLogToFile } from "console-log-to-file"; // or `const { consoleLogToFile } = require("console-log-to-file/dist/index.cjs.js")` consoleLogToFile({ logFilePath: "/log/default.log", }); // all of your console.log/warn/error/info will work as it does and save to file now. 

METHOD STDOUT AND STDERR

This approach can help you (I use something similar in my projects) and works for all methods including console.log, console.warn, console.error, console.info

This method write the bytes written in stdout and stderr to file. Is better than changing console.log, console.warn, console.error, console.info methods, because output will be exact the same as this methods output

 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) 

Adding to the answer above, a lit bit of an expansion to the short and efficient code overriding console.log. Minor additions: set filename with date, wrapper function, also do the original console.logging to keep the console active with the info.

Usage: in the beginning of your code, run setConsoleLogToFile([FILENAME]).

const fs = require("fs"), util = require('util'); const getPrettyDate = ()=> new Date().toString().replace(":","-").replace(/00\s\(.*\)/, "").replace(` ${new Date().getFullYear()}`, ",").replace(/:\d\d\s/, " "); module.exports.getPrettyDate = getPrettyDate; module.exports.setConsoleLogToFile = (filename) => { const log_file = fs.createWriteStream(`${__dirname}/${filename} - ${getPrettyDate()}.log`, { flags: 'w' }), log_stdout = process.stdout; const origConsole = console.log; console.log = (d) => { origConsole(d); log_file.write(util.format(d) + '\n'); log_stdout.write(util.format(d) + '\n'); }; } 

If you are looking for a solution without modifying any code, here is a simple solution.

It requires pm2, just add it to your node modules and start you app with

pm2 start server.js 

And you are done, console.logs are now automatically registered under home/.pm2/logs/server-out.log.

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

You can now use Caterpillar which is a streams based logging system, allowing you to log to it, then pipe the output off to different transforms and locations.

Outputting to a file is as easy as:

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

noogger

simple and straight forward...

For future users. @keshavDulal answer doesn't work for latest version. And I couldn't find a proper fix for the issues that are reporting in the latest version 3.3.3.

Anyway I finally fixed it after researching a bit. Here is the solution for winston version 3.3.3

Install winston and winston-daily-rotate-file

npm install winston npm install winston-daily-rotate-file 

Create a new file utils/logger.js

const winston = require('winston'); const winstonRotator = require('winston-daily-rotate-file'); var logger = new winston.createLogger({ transports: [ new (winston.transports.DailyRotateFile)({ name: 'access-file', level: 'info', filename: './logs/access.log', json: false, datePattern: 'yyyy-MM-DD', prepend: true, maxFiles: 10 }), new (winston.transports.DailyRotateFile)({ name: 'error-file', level: 'error', filename: './logs/error.log', json: false, datePattern: 'yyyy-MM-DD', prepend: true, maxFiles: 10 }) ] }); module.exports = { logger }; 

Then in any file where you want to use logging import the module like

const logger = require('./utils/logger').logger; 

Use logger like the following:

logger.info('Info service started'); logger.error('Service crashed'); 

if you are using forever to keep your node app running, then typing forever list will show you the path to the log file that console.log is writing too

Create a utils/logger.js file with:

var fs = require('fs'); var util = require('util'); var log_file = fs.createWriteStream(__dirname + '/../logs/server.log', { flags: 'w' }); var log_stdout = process.stdout; console.log = function () { // [...arguments].forEach(element => { log_file.write(util.format(element) + '\n'); log_stdout.write(util.format(element) + '\n'); }); }; module.exports = { console } 

Include the logger.js file from any file where you want to console.log like:

const console = require('./utils/logger').console; 

Create a logs folder and create an empty server.log file in it and run your app :)

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; 

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

Rudy Huynh's solution worked really well for me. I added a little bit to have it spit out files with today's date and time.

var dateNow = new Date(); var timeNow = dateNow.getHours() + '-' + dateNow.getMinutes(); var logPath = "log/" + dateNow.toDateString() + ' -' + ' Start Time - ' + timeNow + ".log" consoleLogToFile({ logFilePath: logPath }); 

It's not very elegant but this way it'll save different, easy to read, log files instead of just updating the same "default.log" file.

Based on multiparameter version by Clément, just without color codes for the text file

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 () { // Storing without color codes logFile.write(util.format.apply(null,arguments).replace(/\033\[[0-9;]*m/g,"") + '\n'); // Display normally, with colors to Stdout logStdout.write(util.format.apply(null, arguments) + '\n'); } 

Note: Answering since I couldn't comment