[WIP] Plain ndjson

index.js

@@ -1,62 +1,40 @@
 'use strict'
 
 const chalk = require('chalk')
-const dateformat = require('dateformat')
-// remove jsonParser once Node 6 is not supported anymore
-const jsonParser = require('fast-json-parse')
 const jmespath = require('jmespath')
-const stringifySafe = require('fast-safe-stringify')
-
-const CONSTANTS = require('./lib/constants')
-
-const levels = {
-  default: 'USERLVL',
-  60: 'FATAL',
-  50: 'ERROR',
-  40: 'WARN ',
-  30: 'INFO ',
-  20: 'DEBUG',
-  10: 'TRACE'
+const colors = require('./lib/colors')
+const { ERROR_LIKE_KEYS, MESSAGE_KEY } = require('./lib/constants')
+const {
+  isObject,
+  prettifyErrorLog,
+  prettifyLevel,
+  prettifyMessage,
+  prettifyMetadata,
+  prettifyObject,
+  prettifyTime
+} = require('./lib/utils')
+
+const bourne = require('bourne')
+const jsonParser = input => {
+  try {
+    return { value: bourne.parse(input, { protoAction: 'remove' }) }
+  } catch (err) {
+    return { err }
+  }
 }
 
 const defaultOptions = {
   colorize: chalk.supportsColor,
   crlf: false,
-  errorLikeObjectKeys: ['err', 'error'],
+  errorLikeObjectKeys: ERROR_LIKE_KEYS,
   errorProps: '',
   levelFirst: false,
-  messageKey: CONSTANTS.MESSAGE_KEY,
+  messageKey: MESSAGE_KEY,
   translateTime: false,
   useMetadata: false,
   outputStream: process.stdout
 }
 
-function isObject (input) {
-  return Object.prototype.toString.apply(input) === '[object Object]'
-}
-
-function isPinoLog (log) {
-  return log && (log.hasOwnProperty('v') && log.v === 1)
-}
-
-function formatTime (epoch, translateTime) {
-  const instant = new Date(epoch)
-  if (translateTime === true) {
-    return dateformat(instant, 'UTC:' + CONSTANTS.DATE_FORMAT)
-  } else {
-    const upperFormat = translateTime.toUpperCase()
-    return (!upperFormat.startsWith('SYS:'))
-      ? dateformat(instant, 'UTC:' + translateTime)
-      : (upperFormat === 'SYS:STANDARD')
-        ? dateformat(instant, CONSTANTS.DATE_FORMAT)
-        : dateformat(instant, translateTime.slice(4))
-  }
-}
-
-function nocolor (input) {
-  return input
-}
-
 module.exports = function prettyFactory (options) {
   const opts = Object.assign({}, defaultOptions, options)
   const EOL = opts.crlf ? '\r\n' : '\n'
@@ -66,28 +44,7 @@ module.exports = function prettyFactory (options) {
   const errorProps = opts.errorProps.split(',')
   const ignoreKeys = opts.ignore ? new Set(opts.ignore.split(',')) : undefined
 
-  const color = {
-    default: nocolor,
-    60: nocolor,
-    50: nocolor,
-    40: nocolor,
-    30: nocolor,
-    20: nocolor,
-    10: nocolor,
-    message: nocolor
-  }
-  if (opts.colorize) {
-    const ctx = new chalk.constructor({ enabled: true, level: 3 })
-    color.default = ctx.white
-    color[60] = ctx.bgRed
-    color[50] = ctx.red
-    color[40] = ctx.yellow
-    color[30] = ctx.green
-    color[20] = ctx.blue
-    color[10] = ctx.grey
-    color.message = ctx.cyan
-  }
-
+  const colorizer = colors(opts.colorize)
   const search = opts.search
 
   return pretty
@@ -97,14 +54,19 @@ module.exports = function prettyFactory (options) {
     if (!isObject(inputData)) {
       const parsed = jsonParser(inputData)
       log = parsed.value
-      if (parsed.err || !isPinoLog(log)) {
+      if (parsed.err) {
         // pass through
         return inputData + EOL
       }
     } else {
       log = inputData
     }
 
+    // Short-circuit for spec allowed primitive values.
+    if ([null, true, false].includes(log)) {
+      return `${log}\n`
+    }
+
     if (search && !jmespath.search(log, search)) {
       return
     }
@@ -118,165 +80,67 @@ module.exports = function prettyFactory (options) {
         }, {})
     }
 
-    const standardKeys = [
-      'pid',
-      'hostname',
-      'name',
-      'level',
-      'time',
-      'v'
-    ]
+    const prettifiedLevel = prettifyLevel({ log, colorizer })
+    const prettifiedMessage = prettifyMessage({ log, messageKey, colorizer })
+    const prettifiedMetadata = prettifyMetadata({ log })
+    const prettifiedTime = prettifyTime({ log, translateFormat: opts.translateTime })
 
-    if (opts.translateTime) {
-      log.time = formatTime(log.time, opts.translateTime)
+    let line = ''
+    if (opts.levelFirst && prettifiedLevel) {
+      line = `${prettifiedLevel}`
     }
 
-    var line = log.time ? `[${log.time}]` : ''
-
-    const coloredLevel = levels.hasOwnProperty(log.level)
-      ? color[log.level](levels[log.level])
-      : color.default(levels.default)
-    if (opts.levelFirst) {
-      line = `${coloredLevel} ${line}`
-    } else {
-      // If the line is not empty (timestamps are enabled) output it
-      // with a space after it - otherwise output the empty string
-      const lineOrEmpty = line && line + ' '
-      line = `${lineOrEmpty}${coloredLevel}`
+    if (prettifiedTime && line === '') {
+      line = `${prettifiedTime}`
+    } else if (prettifiedTime) {
+      line = `${line} ${prettifiedTime}`
     }
 
-    if (log.name || log.pid || log.hostname) {
-      line += ' ('
-
-      if (log.name) {
-        line += log.name
-      }
-
-      if (log.name && log.pid) {
-        line += '/' + log.pid
-      } else if (log.pid) {
-        line += log.pid
-      }
-
-      if (log.hostname) {
-        if (line.slice(-1) !== '(') {
-          line += ' '
-        }
-        line += 'on ' + log.hostname
+    if (!opts.levelFirst && prettifiedLevel) {
+      if (line.length > 0) {
+        line = `${line} ${prettifiedLevel}`
+      } else {
+        line = prettifiedLevel
       }
+    }
 
-      line += ')'
+    if (prettifiedMetadata) {
+      line = `${line} ${prettifiedMetadata}:`
     }
 
-    line += ': '
+    if (line.endsWith(':') === false && line !== '') {
+      line += ':'
+    }
 
-    if (log[messageKey] && typeof log[messageKey] === 'string') {
-      line += color.message(log[messageKey])
+    if (prettifiedMessage) {
+      line = `${line} ${prettifiedMessage}`
     }
 
-    line += EOL
+    if (line.length > 0) {
+      line += EOL
+    }
 
     if (log.type === 'Error' && log.stack) {
-      const stack = log.stack
-      line += IDENT + joinLinesWithIndentation(stack) + EOL
-
-      let propsForPrint
-      if (errorProps && errorProps.length > 0) {
-        // don't need print these props for 'Error' object
-        const excludedProps = standardKeys.concat([messageKey, 'type', 'stack'])
-
-        if (errorProps[0] === '*') {
-          // print all log props excluding 'excludedProps'
-          propsForPrint = Object.keys(log).filter((prop) => excludedProps.indexOf(prop) < 0)
-        } else {
-          // print props from 'errorProps' only
-          // but exclude 'excludedProps'
-          propsForPrint = errorProps.filter((prop) => excludedProps.indexOf(prop) < 0)
-        }
-
-        for (var i = 0; i < propsForPrint.length; i++) {
-          const key = propsForPrint[i]
-          if (!log.hasOwnProperty(key)) continue
-          if (log[key] instanceof Object) {
-            // call 'filterObjects' with 'excludeStandardKeys' = false
-            // because nested property might contain property from 'standardKeys'
-            line += key + ': {' + EOL + filterObjects(log[key], '', errorLikeObjectKeys, false) + '}' + EOL
-            continue
-          }
-          line += key + ': ' + log[key] + EOL
-        }
-      }
+      const prettifiedErrorLog = prettifyErrorLog({
+        log,
+        errorLikeKeys: errorLikeObjectKeys,
+        errorProperties: errorProps,
+        ident: IDENT,
+        eol: EOL
+      })
+      line += prettifiedErrorLog
     } else {
-      line += filterObjects(log, typeof log[messageKey] === 'string' ? messageKey : undefined, errorLikeObjectKeys)
+      const skipKeys = typeof log[messageKey] === 'string' ? [messageKey] : undefined
+      const prettifiedObject = prettifyObject({
+        input: log,
+        skipKeys,
+        errorLikeKeys: errorLikeObjectKeys,
+        eol: EOL,
+        ident: IDENT
+      })
+      line += prettifiedObject
     }
 
     return line
-
-    function joinLinesWithIndentation (value) {
-      const lines = value.split(/\r?\n/)
-      for (var i = 1; i < lines.length; i++) {
-        lines[i] = IDENT + lines[i]
-      }
-      return lines.join(EOL)
-    }
-
-    function filterObjects (value, messageKey, errorLikeObjectKeys, excludeStandardKeys) {
-      errorLikeObjectKeys = errorLikeObjectKeys || []
-
-      const keys = Object.keys(value)
-      const filteredKeys = []
-
-      if (messageKey) {
-        filteredKeys.push(messageKey)
-      }
-
-      if (excludeStandardKeys !== false) {
-        Array.prototype.push.apply(filteredKeys, standardKeys)
-      }
-
-      let result = ''
-
-      for (var i = 0; i < keys.length; i += 1) {
-        if (errorLikeObjectKeys.indexOf(keys[i]) !== -1 && value[keys[i]] !== undefined) {
-          const lines = stringifySafe(value[keys[i]], null, 2)
-          if (lines === undefined) continue
-          const arrayOfLines = (
-            IDENT + keys[i] + ': ' +
-            joinLinesWithIndentation(lines) +
-            EOL
-          ).split('\n')
-
-          for (var j = 0; j < arrayOfLines.length; j += 1) {
-            if (j !== 0) {
-              result += '\n'
-            }
-
-            const line = arrayOfLines[j]
-
-            if (/^\s*"stack"/.test(line)) {
-              const matches = /^(\s*"stack":)\s*(".*"),?$/.exec(line)
-
-              if (matches && matches.length === 3) {
-                const indentSize = /^\s*/.exec(line)[0].length + 4
-                const indentation = ' '.repeat(indentSize)
-
-                result += matches[1] + '\n' + indentation + JSON.parse(matches[2]).replace(/\n/g, '\n' + indentation)
-              }
-            } else {
-              result += line
-            }
-          }
-        } else if (filteredKeys.indexOf(keys[i]) < 0) {
-          if (value[keys[i]] !== undefined) {
-            const lines = stringifySafe(value[keys[i]], null, 2)
-            if (lines !== undefined) {
-              result += IDENT + keys[i] + ': ' + joinLinesWithIndentation(lines) + EOL
-            }
-          }
-        }
-      }
-
-      return result
-    }
   }
 }

lib/colors.js

@@ -0,0 +1,52 @@
+'use strict'
+
+const { LEVELS, LEVEL_NAMES } = require('./constants')
+
+const nocolor = input => input
+const plain = {
+  default: nocolor,
+  60: nocolor,
+  50: nocolor,
+  40: nocolor,
+  30: nocolor,
+  20: nocolor,
+  10: nocolor,
+  message: nocolor
+}
+
+const chalk = require('chalk')
+const ctx = new chalk.constructor({ enabled: true, level: 3 })
+const colored = {
+  default: ctx.white,
+  60: ctx.bgRed,
+  50: ctx.red,
+  40: ctx.yellow,
+  30: ctx.green,
+  20: ctx.blue,
+  10: ctx.grey,
+  message: ctx.cyan
+}
+
+function colorizeLevel (level, colorizer) {
+  if (Number.isInteger(+level)) {
+    return LEVELS.hasOwnProperty(level)
+      ? colorizer[level](LEVELS[level])
+      : colorizer.default(LEVELS.default)
+  }
+  const levelNum = LEVEL_NAMES[level.toLowerCase()] || 'default'
+  return colorizer[levelNum](LEVELS[levelNum])
+}
+
+function plainColorizer (level) {
+  return colorizeLevel(level, plain)
+}
+plainColorizer.message = plain.message
+
+function coloredColorizer (level) {
+  return colorizeLevel(level, colored)
+}
+coloredColorizer.message = colored.message
+
+module.exports = function getColorizer (useColors) {
+  return useColors ? coloredColorizer : plainColorizer
+}