Add ability to format time and level with user-defined prettifiers (#263)

Co-authored-by: James Sumners <james@sumners.email>

Author: pearofducks

Readme.md

@@ -238,6 +238,33 @@ const prettifyQuery = value => {
 }
 ```
 
+Additionally, `customPrettifiers` can be used to format the time and level
+outputs:
+```js
+{
+  customPrettifiers: {
+    // The argument for this function will be the same
+    // string that's at the start of the log-line by default:
+    time: timestamp => `🕰 ${timestamp}`,
+
+    // The argument for the level-prettifier may vary depending
+    // on if the levelKey option is used or not.
+    // By default this will be the same numerics as the Pino default:
+    level: logLevel => `LEVEL: ${logLevel}`
+  }
+}
+
+Note that prettifiers do not include any coloring, if the stock coloring on
+`level` is desired, it can be accomplished using the following:
+```js
+const { colorizerFactory } = require('pino-pretty')
+const levelColorize = colorizerFactory(true)
+const levelPrettifier = logLevel => `LEVEL: ${levelColorize(logLevel)}`
+//...
+{
+  customPrettifiers: { level: levelPrettifier }
+}
+
 `messageFormat` option allows you to customize the message output. A template `string` like this can define the format:
 ```js
 {

index.js

@@ -90,9 +90,9 @@ function prettyFactory (options) {
       log = filterLog(log, ignoreKeys)
     }
 
-    const prettifiedLevel = prettifyLevel({ log, colorizer, levelKey })
+    const prettifiedLevel = prettifyLevel({ log, colorizer, levelKey, prettifier: customPrettifiers.level })
     const prettifiedMetadata = prettifyMetadata({ log })
-    const prettifiedTime = prettifyTime({ log, translateFormat: opts.translateTime, timestampKey })
+    const prettifiedTime = prettifyTime({ log, translateFormat: opts.translateTime, timestampKey, prettifier: customPrettifiers.time })
 
     let line = ''
     if (opts.levelFirst && prettifiedLevel) {
@@ -214,4 +214,5 @@ function build (opts = {}) {
 
 module.exports = build
 module.exports.prettyFactory = prettyFactory
+module.exports.colorizerFactory = colors
 module.exports.default = build

lib/utils.js

@@ -218,14 +218,16 @@ function prettifyErrorLog ({
  * @param {function} [input.colorizer] A colorizer function that accepts a level
  * value and returns a colorized string. Default: a no-op colorizer.
  * @param {string} [levelKey='level'] The key to find the level under.
+ * @param {function} [input.prettifier] A user-supplied formatter to be called instead of colorizer.
  *
  * @returns {undefined|string} If `log` does not have a `level` property then
  * `undefined` will be returned. Otherwise, a string from the specified
  * `colorizer` is returned.
  */
-function prettifyLevel ({ log, colorizer = defaultColorizer, levelKey = LEVEL_KEY }) {
+function prettifyLevel ({ log, colorizer = defaultColorizer, levelKey = LEVEL_KEY, prettifier }) {
   if (levelKey in log === false) return undefined
-  return colorizer(log[levelKey])
+  const output = log[levelKey]
+  return prettifier ? prettifier(output) : colorizer(output)
 }
 
 /**
@@ -423,12 +425,13 @@ function prettifyObject ({
  * timestamp will be prettified into a string at UTC using the default
  * `DATE_FORMAT`. If a string, then `translateFormat` will be used as the format
  * string to determine the output; see the `formatTime` function for details.
+ * @param {function} [input.prettifier] A user-supplied formatter for altering output.
  *
  * @returns {undefined|string} If a timestamp property cannot be found then
  * `undefined` is returned. Otherwise, the prettified time is returned as a
  * string.
  */
-function prettifyTime ({ log, timestampKey = TIMESTAMP_KEY, translateFormat = undefined }) {
+function prettifyTime ({ log, timestampKey = TIMESTAMP_KEY, translateFormat = undefined, prettifier }) {
   let time = null
 
   if (timestampKey in log) {
@@ -438,11 +441,9 @@ function prettifyTime ({ log, timestampKey = TIMESTAMP_KEY, translateFormat = un
   }
 
   if (time === null) return undefined
-  if (translateFormat) {
-    return '[' + formatTime(time, translateFormat) + ']'
-  }
+  const output = translateFormat ? formatTime(time, translateFormat) : time
 
-  return `[${time}]`
+  return prettifier ? prettifier(output) : `[${output}]`
 }
 
 /**

test/basic.test.js

@@ -27,6 +27,7 @@ function prettyFactory (opts) {
 
 // All dates are computed from 'Fri, 30 Mar 2018 17:35:28 GMT'
 const epoch = 1522431328992
+const formattedEpoch = '2018-03-30 17:35:28.992 +0000'
 const pid = process.pid
 const hostname = os.hostname()
 
@@ -127,6 +128,86 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'foo', bar: 'warn' })
   })
 
+  t.test('can use a customPrettifier on default level output', (t) => {
+    t.plan(1)
+    const veryCustomLevels = {
+      30: 'ok',
+      40: 'not great'
+    }
+    const customPrettifiers = {
+      level: (level) => `LEVEL: ${veryCustomLevels[level]}`
+    }
+    const pretty = prettyFactory({ customPrettifiers })
+    const log = pino({}, new Writable({
+      write (chunk, enc, cb) {
+        const formatted = pretty(chunk.toString())
+        t.equal(
+          formatted,
+          `[${epoch}] LEVEL: ok (${pid} on ${hostname}): foo\n`
+        )
+        cb()
+      }
+    }))
+    log.info({ msg: 'foo' })
+  })
+
+  t.test('can use a customPrettifier on different-level-key output', (t) => {
+    t.plan(1)
+    const customPrettifiers = {
+      level: (level) => `LEVEL: ${level.toUpperCase()}`
+    }
+    const pretty = prettyFactory({ levelKey: 'bar', customPrettifiers })
+    const log = pino({}, new Writable({
+      write (chunk, enc, cb) {
+        const formatted = pretty(chunk.toString())
+        t.equal(
+          formatted,
+          `[${epoch}] LEVEL: WARN (${pid} on ${hostname}): foo\n`
+        )
+        cb()
+      }
+    }))
+    log.info({ msg: 'foo', bar: 'warn' })
+  })
+
+  t.test('can use a customPrettifier on default time output', (t) => {
+    t.plan(1)
+    const customPrettifiers = {
+      time: (timestamp) => `TIME: ${timestamp}`
+    }
+    const pretty = prettyFactory({ customPrettifiers })
+    const log = pino({}, new Writable({
+      write (chunk, enc, cb) {
+        const formatted = pretty(chunk.toString())
+        t.equal(
+          formatted,
+          `TIME: ${epoch} INFO (${pid} on ${hostname}): foo\n`
+        )
+        cb()
+      }
+    }))
+    log.info('foo')
+  })
+
+  t.test('can use a customPrettifier on translateTime-time output', (t) => {
+    t.plan(1)
+    const customPrettifiers = {
+      time: (timestamp) => `TIME: ${timestamp}`
+    }
+    const pretty = prettyFactory({ customPrettifiers, translateTime: true })
+    const log = pino({}, new Writable({
+      write (chunk, enc, cb) {
+        const formatted = pretty(chunk.toString())
+        t.equal(
+          formatted,
+          `TIME: ${formattedEpoch} INFO (${pid} on ${hostname}): foo\n`
+        )
+        cb()
+      }
+    }))
+    log.info('foo')
+  })
+
   t.test('will format time to UTC', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ translateTime: true })
@@ -135,7 +216,7 @@ test('basic prettifier tests', (t) => {
         const formatted = pretty(chunk.toString())
         t.equal(
           formatted,
-          `[2018-03-30 17:35:28.992 +0000] INFO (${pid} on ${hostname}): foo\n`
+          `[${formattedEpoch}] INFO (${pid} on ${hostname}): foo\n`
         )
         cb()
       }

test/lib/colors.test.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const { test } = require('tap')
-const getColorizer = require('../../lib/colors')
+const getColorizerPrivate = require('../../lib/colors')
+const { colorizerFactory: getColorizerPublic } = require('../../index')
 
-test('returns default colorizer', async t => {
+const testDefaultColorizer = getColorizer => async t => {
   const colorizer = getColorizer()
   let colorized = colorizer(10)
   t.equal(colorized, 'TRACE')
@@ -37,9 +38,9 @@ test('returns default colorizer', async t => {
 
   colorized = colorizer.greyMessage('foo')
   t.equal(colorized, 'foo')
-})
+}
 
-test('returns colorizing colorizer', async t => {
+const testColoringColorizer = getColorizer => async t => {
   const colorizer = getColorizer(true)
   let colorized = colorizer(10)
   t.equal(colorized, '\u001B[90mTRACE\u001B[39m')
@@ -73,4 +74,9 @@ test('returns colorizing colorizer', async t => {
 
   colorized = colorizer.greyMessage('foo')
   t.equal(colorized, '\u001B[90mfoo\u001B[39m')
-})
+}
+
+test('returns default colorizer - private export', testDefaultColorizer(getColorizerPrivate))
+test('returns default colorizer - public export', testDefaultColorizer(getColorizerPublic))
+test('returns colorizing colorizer - private export', testColoringColorizer(getColorizerPrivate))
+test('returns colorizing colorizer - public export', testColoringColorizer(getColorizerPublic))