How to use the winston.format function in winston

return self.action(function () {
      self.setupCommandOutput();

      if (log.format().json) {
        log.verbose('Executing command ' + self.fullName().bold);
      } else {
        log.info('Executing command ' + self.fullName().bold);
      }

      try {
        // pass no more arguments than the function expects, including options and callback at the end (unless it expects 0 or 1)
        var argCount = fn.length <= 1 ? arguments.length : fn.length - 1; // not including callback
        var args = new Array(argCount);
        var optionIndex = arguments.length - 1;
        for (var i = 0; i < arguments.length; ++i) {
          if (typeof arguments[i] === 'object') {
            optionIndex = i;
            break;
          }
          if (i < argCount - 1) {

// https://github.com/amazeeio/lagoon/blob/master/services/api/src/logger.js
import * as fs from "fs";
import * as path from "path";
import { isString } from "util";
import { createLogger, format, transports } from "winston";

// Create the logs directory if it doesn't exist yet.
const directory = path.join(".", "logs");
if (!fs.existsSync(directory)) {
  fs.mkdirSync(directory);
}

const ignorePingAndMedia = format(info => {
  const message = info.message;

  if (
    isString(message) &&
    ["GET /ping ", "GET /media"].some(match => message.includes(match))
  ) {
    return false;
  }

  return info;
});

const logger = createLogger({
  exitOnError: false,
  format: format.combine(ignorePingAndMedia(), format.json()),
  transports: [

progress: function(label) {
    var self = this;

    var verbose = log.format().json || log.format().level === 'verbose' || log.format().level === 'silly';
    if (!self.istty1 || verbose)  {
      (verbose ? log.verbose : log.info)(label);
      return { end: function() {} };
    }

    // clear any previous progress
    self.clearProgress();

    // Clear the console
    fs.writeSync(1, '\r' + self.clearBuffer);

    // Draw initial progress
    self.drawAndUpdateProgress();

    // Draw label
    if (label) {

info: 6,
  verbose: 7,
  debug: 8,
  silly: 9
}

const formattedJson = winston.format((log) => {
  let sortedFields = ['level', 'timestamp', 'message']
  if (log.args) {
    sortedFields = sortedFields.concat(['args']).concat(getAllObjKeys(log.args))
  }
  log[MESSAGE] = JSON.stringify(log, sortedFields)
  return log
})

const prepareObjectLogs = winston.format((log) => {
  if (!(log.message instanceof Object)) {
    return log
  }

  if (log.level === 'apiReq' && log.message instanceof Object) {
    const req = log.message
    log.message = `${req.method} ${req.originalUrl}`
    log.args = { params: req.params, query: req.query, body: req.body }
  }
  if (log.level === 'apiRes' && log.message instanceof Object) {
    const req = log.message.req
    const res = log.message.res
    log.message = `${req.method} ${req.originalUrl}`
    log.args = res
  }
  return log

import winston, { format } from 'winston'
import os from 'os'
import { session } from './session'

const requestId = format((info) => {
  info.requestId = session.get('requestId')
  return info
})

function createLogger (label: string) {
  return winston.createLogger({
    defaultMeta: {
      serverName: os.hostname(),
      label
    },
    format: format.combine(
      format.timestamp(),
      requestId(),
      format.json()
    ),
    transports: [

var _getWinstonConsole = function() {
    const winston = require("winston");
    const {combine, colorize, simple} = winston.format;
    const _simple = simple();
    const myFormat = winston.format(info => {
        const stringifiedRest = processJSON(Object.assign({}, info, {
            level: undefined,
            message: undefined,
            splat: undefined
        }));
        var new_info = {level: info.level, message: info.message};
        if (new_info.message == undefined){
            new_info.message = "";
        }
        if (stringifiedRest !== '{}') {
            new_info.message += stringifiedRest;
        }
        return _simple.transform(new_info);
    });

    const logger = winston.createLogger({

}

const MESSAGE = Symbol.for('message');

const jsonFormatter = (logEntry) => {
  const modifiedLog = logEntry;
  const base = {
    timestamp: new Date(),
  };
  const json = Object.assign(base, logEntry);
  modifiedLog[MESSAGE] = JSON.stringify(json);
  return modifiedLog;
};

const logger = winston.createLogger({
  format: winston.format(jsonFormatter)(),
  transports: [
    new winston.transports.File({
      level: 'info',
      filename: `${process.env.LOGS_FOLDER}/${process.env.INFO_LOG || 'info.log'}`,
      handleExceptions: true,
      json: true,
    }),
    new winston.transports.File({
      level: 'error',
      filename: `${process.env.LOGS_FOLDER}/${process.env.ERROR_LOG || 'error.log'}`,
      handleExceptions: true,
      json: true,
    }),
    new winston.transports.File({
      level: 'warn',
      filename: `${process.env.LOGS_FOLDER}/${process.env.WARNINGS_LOG || 'warn.log'}`,

* Helper function to test is a string is a stringified version of a JSON object
 * @param {string} str - the input string to test
 * @returns {boolean} - true iff the string can be parsed as JSON
 * @private
 */
function isJSON(str) {
    try {
        return (JSON.parse(str) && !!str);
    } catch (e) {
        return false;
    }
}

jsome.params.lintable = true;

const jsonColor =  winston.format(info => {
    const padding = info.padding && info.padding[info.level] || '';

    if(info[LEVEL] === 'error' && info.stack) {
        info[MESSAGE] = `${tsFormat()} - ${info.level}:${padding} ${info.message}\n${info.stack}`;
        return info;
    }

    if (info[LEVEL] === 'info') {
        if(typeof info.message === 'object') {
            info[MESSAGE] = `${tsFormat()} - ${info.level}:${padding}\n${jsome.getColoredString(info.message, null, 2)}`;
        } else if(isJSON(info.message)) {
            info[MESSAGE] =`${tsFormat()} - ${info.level}:${padding}\n${jsome.getColoredString(JSON.parse(info.message), null, 2)}`;
        } else {
            info[MESSAGE] = `${tsFormat()} - ${info.level}:${padding} ${info.message}`;
        }
        return info;

function parametersToMessage() {
  return winston.format((info) => {
    if (info[SPLAT]) {
      return {
        ...info,
        "message": info.message + info[SPLAT].join(" "),
      };
    }
    return info;
  })();
}

import { format as formatDate } from 'date-fns';
import * as path from 'path';
import { createLogger, format, transports } from 'winston';
const { combine, timestamp, label, printf } = format;
import * as util from 'util';
import { mkdir } from './util';

const mysplat = format((info) => {
  if (info.splat) {
    info.message = util.format(info.message, ...info.splat);
    info.splat = undefined;
  }
  return info;
});

const logdir = './logs';

export function getLogger(name: string): Logger {
  mkdir(logdir);
  const localtime = () => formatDate(new Date(), 'YYYY-MM-DD HH:mm:ss.SSS');
  const formatForConsole = combine(
    mysplat(), 
    format.colorize(), 
    printf(info => `[${info.level}] ${info.message}`)