How to log JavaScript objects and arrays in winston as console.log does?

Question

I was looking at top Node logging systems: npmlog, log4js, bunyan and winston and decided to use winston for having the most npm monthly downloads.

What I want to set up is custom logger which I will be able to use on development environment with logger.debug(...) which won't log anything on production environment. This will help me so when I'm on development environment, I won't need to write anything since I'll see all the outputs.

This is what I have now:

var level = 'debug';
if (process.env.NODE_ENV !== 'development'){
  level = 'production'; // this will never be logged!
}

var logger = new winston.Logger({
  transports: [
    // some other loggings
    new winston.transports.Console({
      name: 'debug-console',
      level: level,
      prettyPrint: true,
      handleExceptions: true,
      json: false,
      colorize: true
    })

  ],
  exitOnError: false // don't crush no error
});

Problem occurs when I'm trying to log JavaScript Object or Javascript Array. With Object, I need to do toJSON(), and for Array I need first JSON.stringify() and then JSON.parse().

It's not nice to write all the time this methods, just to log something that I want. Furthermore, it's not even resource-friendly, because those formatting methods need to be executed before logger.debug() realises that it's on production and that it shouldn't log it in the first place (basically, it's evaluating arguments before function call). I just like how old-fashined console.log() logs JavaScript objects and arrays.

Now, as I'm writing this question, I found that there is a way of describing custom format for every winston transports object. Is that the way of doing it, or is there some other way?

Leo · Answer 1 · 2018-02-13T16:57:38.610

32

logger.log("info", "Starting up with config %j", config);

Winstons uses the built-in utils.format library. https://nodejs.org/dist/latest/docs/api/util.html#util_util_format_format_args

edited Feb 13 '18 at 16:57

answered Oct 27 '17 at 11:09

Leo

1,102
2
11
18

5

Provide some explanation to your answer to why it works like this or what the OP was doing wrong. Just a code paste like this gets flagged. – Alexander Morland Oct 27 '17 at 12:59
1

Best solution I've seen here. Uses the existing logger api and prints everything pretty. – Chris Pawlukiewicz Nov 03 '17 at 17:10
6

Just a reminder, you need to have format.splat() enabled. Otherwise it does not work. – Haijin Dec 05 '18 at 17:46

score 15 · Accepted Answer · answered Jun 09 '16 at 18:16

15

try changing prettyPrint parameter to

prettyPrint: function ( object ){
    return JSON.stringify(object);
}

answered Jun 09 '16 at 18:16

Bharat Kul Ratan

985
2
12
24

11

Fun fact, you can also do `prettyPrint: JSON.stringify` – Cameron Wilby Jun 27 '18 at 02:44
4

Wont this fail if `object` has circular reference? – Hanu Sep 26 '18 at 01:09
Yes absolutely it will fail in circular JSON. I have added an answer where I resolved the problem by using util.format function. – logeekal Sep 13 '19 at 12:36

score 8 · Answer 3 · edited Sep 04 '19 at 10:00

8

In Winston > 3 you can use

logger.log('%o', { lol: 123 }')

Anyway... Couldn't accept that I have to use %o always and made this simple solution:

const prettyJson = format.printf(info => {
  if (info.message.constructor === Object) {
    info.message = JSON.stringify(info.message, null, 4)
  }
  return `${info.level}: ${info.message}`
})

const logger = createLogger({
  level: 'info',
  format: format.combine(
    format.colorize(),
    format.prettyPrint(),
    format.splat(),
    format.simple(),
    prettyJson,
  ),
  transports: [
    new transports.Console({})
  ],
})

So this logger....

  logger.info({ hi: 123 })

...transforms to this in the console

info: {
    "hi": 123
}

edited Sep 04 '19 at 10:00

Dharman

30,962
25
85
135

answered Jun 30 '19 at 11:57

smith64fx

329
2
10

1

Unfortunately your answer won't work with: `log.silly(\`Ok: ${{ lol: 123 }}\`);` :( – basickarl Sep 04 '19 at 10:00
@K-ToxicityinSOisgrowing. Did you find any solution to this? – FabZbi Jun 18 '20 at 20:46
@FabZbi I created my own log library: https://github.com/langurama/log – basickarl Jun 22 '20 at 13:26

score 4 · Answer 4 · answered Jun 15 '17 at 17:00

4

Use the built-in Node.js function util.format to convert your objects to strings in the same way that console.log does.

answered Jun 15 '17 at 17:00

Resigned June 2023

4,638
3
38
49

score 2 · Answer 5 · edited May 23 '17 at 12:09

2

My recommendation is to write your own abstraction on top of winston that has a convenience method for printing your objects for debugging.

You may also look at this response for a hint of how the method could be developed.

https://stackoverflow.com/a/12620543/2211743

edited May 23 '17 at 12:09

Community

1
1

answered Oct 16 '15 at 02:58

ambrons

136
1
7

score 1 · Answer 6 · answered May 29 '18 at 11:31

As Leo already pointed out in his answer, Winston makes use of String Interpolation provided by util.format:

const winston = require("winston");                                                                                                                                                                                                    
const logger = new winston.Logger({                                                                                                                                                                                                    
  transports: [                                                                                                                                                                                                                        
    // some other loggings                                                                                                                                                                                                             
    new winston.transports.Console({                                                                                                                                                                                                   
      name: "debug-console",                                                                                                                                                                                                           
      level: process.env.LOGLEVEL || "info",                                                                                                                                                                                           
      prettyPrint: true,                                                                                                                                                                                                               
      handleExceptions: true,                                                                                                                                                                                                          
      json: false,                                                                                                                                                                                                                     
      colorize: true                                                                                                                                                                                                                   
    })                                                                                                                                                                                                                                 
  ],                                                                                                                                                                                                                                   
  exitOnError: false // don't crush no error                                                                                                                                                                                           
});                                                                                                                                                                                                                                    

const nestedObj = {                                                                                                                                                                                                                    
  foo: {                                                                                                                                                                                                                               
    bar: {                                                                                                                                                                                                                             
      baz: "example"                                                                                                                                                                                                                   
    }                                                                                                                                                                                                                                  
  }                                                                                                                                                                                                                                    
};                                                                                                                                                                                                                                     

const myString = "foo";                                                                                                                                                                                                                

logger.log("info", "my nested object: %j. My string: %s", nestedObj, myString);

When calling logger.log, you can define placeholders which will be appropriately replaced. %j will be replaced by the equivalent of JSON.stringify(nestedObj)

logeekal · Answer 7 · 2019-09-13T12:57:40.093

Try using util.inspect for objects. It handles circular references correctly as well. @radon-rosborough has already given this answer but I thought of adding an example. Please see below

const customTransports = [
    new winston.transports.Console({
        format: combine(
            timestamp({
                format: 'DD-MMM-YYYY HH:MM:SS'
            }),
            label({
                label: file
            }),
            prettyPrint(),
            format.splat(),
            simple(),
            printf( (msg)=> {
                let message = msg.message;

                return colorize().colorize(msg.level, `${ msg.level } :  ${msg.timestamp} :  ${ msg.label } : \n`) + `${ util.inspect(message,{
                    depth: 2,
                    compact:true,
                    colors: true,
                } )}`;
            })
        )
    })
]

score 0 · Answer 8 · answered Aug 22 '19 at 17:24

Instead of doing

prettyPrint: function ( object ){
    return JSON.stringify(object)
}

it's better go with utils-deep-clone package

// initialize package on the top
const { toJSON } = require('utils-deep-clone')


// and now in your `prettyPrint` parameter do this
prettyPrint: function ( object ){
    return toJSON(object)
}

if you'll go with JSON.stringify you won't be able to print error

console.log(JSON.stringify(new Error('some error')))
// output will '{}'

How to log JavaScript objects and arrays in winston as console.log does?

8 Answers8