ice.fo.utils/ServerLogger.js

const useLogger = (function () {
  try {
    return require('winston').version.split('.')[0] >= 3
  } catch (er) {
    return false
  }
})()

function buildConsoleColorForText (text, color) {
  return `${color}${text}\x1B[0m`
}

function buildConsoleDataMessage (data) {
  const tab = '  '
  const keyColor = '\x1B[32m'
  let result = ''

  const keys = Object.keys(data)
  const longest = keys.reduce((r, i) => Math.max(r, i.length), 0)

  for (const k in data) {
    result += tab + buildConsoleColorForText(k.padEnd(longest, ' '), keyColor) + tab + (data[k] + '') + '\n'
  }
  return result + '\n'
}

class ServerLogger {
  constructor (logger) {
    this.logger = logger
  }

  /**
   * There are 3 use cases
   *
   * 1 parameter => info(message: string)
   *
   * 2 parameters => info(message: string, data: object)
   * 2 parameters => info(label: string, message: string)
   *
   * 3 parameters => ?
   *
   * @param  {...any} args
   */
  info (...args) {
    switch (args.length) {
      case 1:
        {
          const [message] = args
          this.logger.info(message)
        }
        break
      case 2:
        {
          const [message, data] = args
          this.logger.info(message, data)
        }
        break
      case 3:
        break
    }
  }

  /**
   * There are 3 use cases
   *
   * 1 parameter => error(message: string)
   *
   * 2 parameters => error(message: string, data: any)
   *
   * 3 parameters => ?
   *
   * @param  {...any} args
   */
  error (...args) {
    switch (args.length) {
      case 1:
        {
          const [message] = args
          this.logger.error({
            message,
            label: 'Server Logger',
          })
        }
        break
      case 2:
        if (typeof args[1] == 'string') {
          const [label, message] = args
          this.logger.error({
            message,
            label,
          })
        } else {
          const [message, data] = args
          this.logger.error({
            message,
            label: 'Server Logger',
            data,
          })
        }
        break
      case 3:
        {
          const [label, message, data] = args
          this.logger.log({
            level: 'error',
            message,
            label,
            data,
          })
        }
        break
    }
  }
}

export function createLogger (prefix = 'request') {
  if (!useLogger) {
    return null
  }

  const winston = require('winston')

  const logger = winston.createLogger({
    level: 'info',
    format: winston.format.combine(
      winston.format.timestamp(),
      winston.format.errors({ stack: true }),
      winston.format.json(),
    ),
    defaultMeta: { },
    transports: [
    //
    // - Write all logs with level `error` and below to `error.log`
    // - Write all logs with level `info` and below to `combined.log`
    //
      new winston.transports.File({ filename: `logs/${prefix}_error.log`, level: 'error' }),
      new winston.transports.File({ filename: `logs/${prefix}_all.log`, maxsize: 5 * 1e+6 }),
    ],
  })

  //
  // 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({
      level: 'error',
      format: winston.format.printf((info) => {
        // Color: https://stackoverflow.com/questions/9781218/how-to-change-node-jss-console-font-color
        const level = info.level == 'error' ? '\x1B[41m ERROR \x1B[0m ' : '\x1B[46m INFO \x1B[0m '
        const label = info.label ? `[ ${info.label} ] ` : ''
        const message = info.message

        const text = `${level}${label}${message}`

        if (!info.data) {
          return text + '\n'
        }

        return text + '\n' + buildConsoleDataMessage(info.data)
      }),
    }))
  }

  return new ServerLogger(logger)
}