gistfile1.txt

import winston from 'winston';
import morgan from 'morgan';

const env = process.env;

const loggerConfig = Object.freeze({
  level: env.LOG_LEVEL || 'debug',
  serviceInfo: {
    service: env.service || 'unknown',
    env: env.NODE_ENV || 'dev',
  },
});

const morganLogFormat = JSON.stringify({
  ...loggerConfig.serviceInfo,
  date: ':date[clf]',
  method: ':method',
  url: ':url',
  remoteAddr: ':remote-addr',
  remoteUser: ':remote-user',
  httpVersion: ':http-version',
  status: ':status',
  resultLength: ':res[content-length]',
  referrer: ':referrer',
  userAgent: ':user-agent',
  responseTime: ':response-time',
});


const winstonLogger = createWinstonLogger();
createWinstonStreamForMorgan();

const logger = {
  middleware: createMorgan(),
  error: (message, context) => { return createLogEntry('error', message, context); },
  warn: (message, context) => { return createLogEntry('warn', message, context); },
  info: (message, context) => { return createLogEntry('info', message, context); },
  debug: (message, context) => { return createLogEntry('debug', message, context); },
};

function createWinstonLogger() {
  return new winston.Logger({
    transports: createWinstonTransforms(),
  });
}

function createMorgan() {
  if (loggerConfig.serviceInfo.env === 'dev') {
    return morgan('dev');
  } else {
    return morgan(morganLogFormat, { stream: winstonLogger.stream });
  }
}

function createWinstonTransforms() {
  if (loggerConfig.serviceInfo.env === 'dev') {
    return [
      new winston.transports.Console({
        level: loggerConfig.level,
        timestamp: true,
        colorize: true,
        stringify: true,
      }),
    ];
  } else {
    return [
      new winston.transports.Console({
        level: loggerConfig.level,
        timestamp: true,
        json: true,
      }),
      //some production logging transport
    ];
  }
}

function createLogEntry(level, message, context) {
  if (typeof message === 'object') {
    return winstonLogger[level]('', { level, ...message, ...loggerConfig.serviceInfo });
  } else {
    return winstonLogger[level](message, { level, message, ...context, ...loggerConfig.serviceInfo });
  }
}

function createShortMessage(message) {
  return `${message.method} - ${message.url} - ${message.status} - ${message.responseTime} ms`;
}

function createWinstonStreamForMorgan() {
  winstonLogger.stream = {
    write: (rawMessage) => {
      const message = JSON.parse(rawMessage);
      const shortMessage = createShortMessage(message);

      if (message.status < 400) {
        message.level = 'info';
        winstonLogger.info(shortMessage, message);
      } else if (message.status < 500) {
        message.level = 'warn';
        winstonLogger.warn(shortMessage, message);
      } else {
        message.level = 'error';
        winstonLogger.error(shortMessage, message);
      }
    },
  };
}

export default logger;