func (l *MyLogger) Fatalf(format string, args ...interface{}) {
	l.Logger.Fatalf(format, args...)
}
Fatalf output format message of fatal level
package log
import (
	"encoding/json"
	"io"
	"github.com/labstack/gommon/log"
	"github.com/sirupsen/logrus"
)
type MyLogger struct {
	*logrus.Logger
}
var singletonLogger = &MyLogger{
	Logger: logrus.New(),
}
func Logger() *MyLogger {
	return singletonLogger
}
func Print(i ...interface{}) {
	singletonLogger.Print(i...)
}
func Printf(format string, i ...interface{}) {
	singletonLogger.Printf(format, i...)
}
func Printj(j log.JSON) {
	singletonLogger.Printj(j)
}
func Debug(i ...interface{}) {
	singletonLogger.Debug(i...)
}
func Debugf(format string, args ...interface{}) {
	singletonLogger.Debugf(format, args...)
}
func Debugj(j log.JSON) {
	singletonLogger.Debugj(j)
}
func Info(i ...interface{}) {
	singletonLogger.Info(i...)
}
func Infof(format string, args ...interface{}) {
	singletonLogger.Infof(format, args...)
}
func Infoj(j log.JSON) {
	singletonLogger.Infoj(j)
}
func Warn(i ...interface{}) {
	singletonLogger.Warn(i...)
}
func Warnf(format string, args ...interface{}) {
	singletonLogger.Warnf(format, args...)
}
func Warnj(j log.JSON) {
	singletonLogger.Warnj(j)
}
func Error(i ...interface{}) {
	singletonLogger.Error(i...)
}
func Errorf(format string, args ...interface{}) {
	singletonLogger.Errorf(format, args...)
}
func Errorj(j log.JSON) {
	singletonLogger.Errorj(j)
}
func Fatal(i ...interface{}) {
	singletonLogger.Fatal(i...)
}
func Fatalf(format string, args ...interface{}) {
	singletonLogger.Fatalf(format, args...)
}
func Fatalj(j log.JSON) {
	singletonLogger.Fatalj(j)
}
func Panic(i ...interface{}) {
	singletonLogger.Panic(i...)
}
func Panicf(format string, args ...interface{}) {
	singletonLogger.Panicf(format, args...)
}
func Panicj(j log.JSON) {
	singletonLogger.Panicj(j)
}
func toLogrusLevel(level log.Lvl) logrus.Level {
	switch level {
	case log.DEBUG:
		return logrus.DebugLevel
	case log.INFO:
		return logrus.InfoLevel
	case log.WARN:
		return logrus.WarnLevel
	case log.ERROR:
		return logrus.ErrorLevel
	}
	return logrus.InfoLevel
}
func toEchoLevel(level logrus.Level) log.Lvl {
	switch level {
	case logrus.DebugLevel:
		return log.DEBUG
	case logrus.InfoLevel:
		return log.INFO
	case logrus.WarnLevel:
		return log.WARN
	case logrus.ErrorLevel:
		return log.ERROR
	}
	return log.OFF
}
func (l *MyLogger) Output() io.Writer {
	return l.Out
}
func (l *MyLogger) SetOutput(w io.Writer) {
	l.Out = w
}
func (l *MyLogger) Level() log.Lvl {
	return toEchoLevel(l.Logger.Level)
}
func (l *MyLogger) SetLevel(v log.Lvl) {
	l.Logger.Level = toLogrusLevel(v)
}
func (l *MyLogger) SetHeader(h string) {
}
func (l *MyLogger) Formatter() logrus.Formatter {
	return l.Logger.Formatter
}
func (l *MyLogger) SetFormatter(formatter logrus.Formatter) {
	l.Logger.Formatter = formatter
}
func (l *MyLogger) Prefix() string {
	return ""
}
func (l *MyLogger) SetPrefix(p string) {
}
func (l *MyLogger) Print(i ...interface{}) {
	l.Logger.Print(i...)
}
func (l *MyLogger) Printf(format string, args ...interface{}) {
	l.Logger.Printf(format, args...)
}
func (l *MyLogger) Printj(j log.JSON) {
	b, err := json.Marshal(j)
	if err != nil {
		panic(err)
	}
	l.Logger.Println(string(b))
}
func (l *MyLogger) Debug(i ...interface{}) {
	l.Logger.Debug(i...)
}
func (l *MyLogger) Debugf(format string, args ...interface{}) {
	l.Logger.Debugf(format, args...)
}
func (l *MyLogger) Debugj(j log.JSON) {
	b, err := json.Marshal(j)
	if err != nil {
		panic(err)
	}
	l.Logger.Debugln(string(b))
}
func (l *MyLogger) Info(i ...interface{}) {
	l.Logger.Info(i...)
}
func (l *MyLogger) Infof(format string, args ...interface{}) {
	l.Logger.Infof(format, args...)
}
func (l *MyLogger) Infoj(j log.JSON) {
	b, err := json.Marshal(j)
	if err != nil {
		panic(err)
	}
	l.Logger.Infoln(string(b))
}
func (l *MyLogger) Warn(i ...interface{}) {
	l.Logger.Warn(i...)
}
func (l *MyLogger) Warnf(format string, args ...interface{}) {
	l.Logger.Warnf(format, args...)
}
func (l *MyLogger) Warnj(j log.JSON) {
	b, err := json.Marshal(j)
	if err != nil {
		panic(err)
	}
	l.Logger.Warnln(string(b))
}
func (l *MyLogger) Error(i ...interface{}) {
	l.Logger.Error(i...)
}
func (l *MyLogger) Errorf(format string, args ...interface{}) {
	l.Logger.Errorf(format, args...)
}
func (l *MyLogger) Errorj(j log.JSON) {
	b, err := json.Marshal(j)
	if err != nil {
		panic(err)
	}
	l.Logger.Errorln(string(b))
}
func (l *MyLogger) Fatal(i ...interface{}) {
	l.Logger.Fatal(i...)
}