Adding timestamps to all console messages

Question

I have a complete, deployed, Express-based project, with many console.log() and console.error() statements throughout. The project runs using forever, directing the stdout and stderr to 2 separate files.

It all works quite well, but now I'm missing timestamps - to know exactly when errors occurred.

I can do some kind of search/replace throughout my code, or use some npm module that overrides console in each file, but I do not want to touch every model/route file, unless I absolutely have to.

Is there a way, perhaps an Express middleware, that would allow me to add a timestamp to every call made, or do I have to manually add it?

Answer 1

I really like @AndreasHultgren's solution but it did not accept arguments so I expanded on it.

let warnLog = console.warn;
console.warn = (...strings) => {
    let firstFormat = strings.shift();
    let dateFormat = '[' + date.format(new Date(), 'YYYY-MM-DD HH:mm:ss') + '] WARN: ' + firstFormat;
    strings.unshift(dateFormat);
    warnLog(...strings);
};

let errorLog = console.error;
console.error = (...strings) => {
    let firstFormat = strings.shift();
    let dateFormat = '[' + date.format(new Date(), 'YYYY-MM-DD HH:mm:ss') + '] ERROR: ' + firstFormat;
    strings.unshift(dateFormat);
    errorLog(...strings);
};

Far off in another part of my NodeJS project.

console.error('settings being read by %s and %s', 'steve', 'tom');
console.warn('Your %s wears %s', 'mother', 'army boots');

Answer 2

You can allways use log4j, as its written in doku to use third party tools.

I can recommend using the log4j. It does gives more than time but this is a good entry for the future impovements as well.

Please find below example implementation

var log4js = require('log4js');
var logger = log4js.getLogger();
logger.level = 'info';
logger.log('your log message');

Example output

[2023-05-01T15:24:12.948] [INFO] default - your log message

Answer 3

An answer suitable for 2022

const log = console.log;

console.log = function(){
    log.apply(console, [new Date(), ...arguments]);
};

Answer 4

A more rudimentary approach, to avoid installing external modules, could be implementing a simple function such as:

function timeStamp(message){
    console.log ( '[' + new Date().toISOString().substring(11,23) + '] -', message )
}

and then I simply call it in this way:

timeStamp('this is my logline!!');

the result will be:

 LOG  [15:22:30.682] - this is my logline!!

of course you can format the date in the best format you need and expand the function to console.error, debug, etc.

Answer 5

The module log-timestamp works for me.

npm install log-timestamp

It's simple to use:

console.log('Before log-timestamp');
require('log-timestamp');
console.log('After log-timestamp');

Before log-timestamp
[2012-08-23T20:08:32.000Z] After log-timestamp

Answer 6

It turns out, you can override the console functions at the top of the app.js file, and have it take effect in every other module. I got mixed results because one of my modules is forked as a child_process. Once I copied the line to the top of that file as well, all works.

For the record, I installed the module console-stamp (npm install console-stamp --save), and added this line to the top of app.js and childProcess.js:

// add timestamps in front of log messages
require('console-stamp')(console, '[HH:MM:ss.l]');

My problem now was that the :date format of the connect logger uses UTC format, rather than the one I'm using in the other console calls. That was easily fixed by registering my own time format (and as a side effect, requiring the dateformat module that console stamp comes with, rather than installing another one):

// since logger only returns a UTC version of date, I'm defining my own date format - using an internal module from console-stamp
express.logger.format('mydate', function() {
    var df = require('console-stamp/node_modules/dateformat');
    return df(new Date(), 'HH:MM:ss.l');
});
app.use(express.logger('[:mydate] :method :url :status :res[content-length] - :remote-addr - :response-time ms'));

Now my log files look organized (and better yet, parseable):

[15:09:47.746] staging server listening on port 3000
[15:09:49.322] connected to database server xxxxx successfully
[15:09:52.743] GET /product 200 - - 127.0.0.1 - 214 ms
[15:09:52.929] GET /stylesheets/bootstrap-cerulean.min.css 304 - - 127.0.0.1 - 8 ms
[15:09:52.935] GET /javascripts/vendor/require.js 304 - - 127.0.0.1 - 3 ms
[15:09:53.085] GET /javascripts/product.js 304 - - 127.0.0.1 - 2 ms
...

Answer 7

I'm trying overwriting the console object - seems to be working well. To use, save the code below in a file, and then import to overwrite the proxy object, and then use as normal.

(Note this requires babel transpilation and won't work in environments that don't support the JavaScript Proxy constructor such as IE 11).

import console from './console-shadow.js'

console.log(...)
console.warn(...)
console.error(...)

// console-shadow.js

// Only these functions are shadowed by default
const overwrites = ['log', 'warn', 'info', 'error']

export default new Proxy(
  // Proxy (overwrite console methods here)
  {},

  // Handler
  {
    get: (obj, prop) =>
      prop in obj
        ? obj[prop]
        : overwrites.includes(prop)
        ? (...args) => console[prop].call(console, new Date(), ...args)
        : console[prop],
  }
)

Basically I overwrite the console object with a JavaScript proxy object. When you call .log, .warn, etc. the overwritten console will check if what you are calling is a function, if so it will inject a date into the log statement as the first parameter, followed by all your parameters.

I think the console object actually does a lot, and I don't fully understand it. So I only intercept console.log, console.info, console.warn, console.error calls.

Answer 8

If you wish, you may create a custom logger for your application by extending the Node's build in "Console" class. Kindly refer to the following implementation

"use strict";

const moment = require('moment');
const util = require('util');
const Console = require('console').Console;

class Logger extends Console {
    constructor(stdout, stderr, ...otherArgs) {
        super(stdout, stderr, ...otherArgs);
    }

    log(...args) {
        super.log(moment().format('D MMM HH:mm:ss'), '-', util.format(...args));
    }

    error(...args) {
        super.error(moment().format('D MMM HH:mm:ss'), '-', util.format(...args));
    }
}

module.exports = (function() {
    return new Logger(process.stdout, process.stderr); 
}());

After that, you may use it in your code as :

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

logger.log('hello world', 123456);
logger.error('some error occurred', err);

Answer 9

You can use a function util.log from https://nodejs.org/api/util.html.

Be aware that it was deprecated since version 6.0.0.

For higher versions you should "Use a third party module instead."

Answer 10

Use event listener like this,

process.on('error', function() { 
   console.log('Error Occurred.');

   var d = Date(Date.now()).toString();
   console.log.call(console, d); // Wed Aug 07 2019 23:40:07 GMT+0100 (GMT+01:00)
});

happy coding :)

Answer 11

app.use(morgan('[:date[web]] :method :url :status :res[content-length] - :remote-addr - :response-time ms'))

Answer 12

This implementation is simple, supports original functionality of console.log (passing a single object, and variable substitution), doesn't use external modules and prints everything in a single call to console.log:

var origlog = console.log;

console.log = function( obj, ...placeholders ){
    if ( typeof obj === 'string' )
        placeholders.unshift( Date.now() + " " + obj );
    else
    {
        // This handles console.log( object )
        placeholders.unshift( obj );
        placeholders.unshift( Date.now() + " %j" );
    }

    origlog.apply( this, placeholders );
};

Answer 13

If you want a solution without another external dependency but you want to keep the full functionalities of console.log (multiple parameters, variable insertion) you can use the following code:

var log = console.log;

console.log = function () {
    var first_parameter = arguments[0];
    var other_parameters = Array.prototype.slice.call(arguments, 1);

    function formatConsoleDate (date) {
        var hour = date.getHours();
        var minutes = date.getMinutes();
        var seconds = date.getSeconds();
        var milliseconds = date.getMilliseconds();

        return '[' +
               ((hour < 10) ? '0' + hour: hour) +
               ':' +
               ((minutes < 10) ? '0' + minutes: minutes) +
               ':' +
               ((seconds < 10) ? '0' + seconds: seconds) +
               '.' +
               ('00' + milliseconds).slice(-3) +
               '] ';
    }

    log.apply(console, [formatConsoleDate(new Date()) + first_parameter].concat(other_parameters));
};

You can modify the formatConsoleDate function to format the date how you want.

This code needs to be written only once on top of your main JavaScript file.

console.log("he%s", "y") will print something like this:

[12:22:55.053] hey

Answer 14

You could also use the log-timestamp package. It's quite straightforward, and customizable as well.

Answer 15

Create a file with the following:

var log = console.log;

console.log = function(){
  log.apply(console, [Date.now()].concat(arguments));
};

Require it in your app before you log anything. Do the same for console.error if needed.

Note that this solution will destroy variable insertion (console.log("he%s", "y") // "hey") if you're using that. If you need that, just log the timestamp first:

log.call(console, Date.now());
log.apply(console, arguments);

Answer 16

This isn't a direct answer, but have you looked into winston.js? It has a ton more logging options including logging to a json file or database. These always have timestamps by default. Just a thought.