func LoggerMiddleware(logger logger.Logger) gin.HandlerFunc {
	return func(c *gin.Context) {
		t := time.Now()
		c.Next()
		latency := time.Now().Sub(t)
		logger.Info(
			"latency", latency,
			"status", c.Writer.Status(),
			"path", c.Request.URL.Path,
			"method", c.Request.Method,
			"ip", c.ClientIP(),
			"user-agent", c.Request.UserAgent(),
		)
	}
}

type Logger interface {
	Info(...interface{})
	Error(...interface{})
	Debug(...interface{})
	Warn(...interface{})
	Fatal(...interface{})
}

var _ Logger = (*FileLogger)(nil)

type FileLogger struct {
	log    *zap.Logger
	prefix []interface{}
}

var DefaultLoggerSavePath = "./logs"

func NewFileLogger(level Level) *FileLogger {
	logSavePath := os.Getenv("GIN_LOG_PATH")
	if logSavePath == "" {
		logSavePath = DefaultLoggerSavePath
	}
	rotateLogger, err := rotatelogs.New(logSavePath+"/%Y%m%d.log", rotatelogs.WithMaxAge(time.Hour*24*30))
	if err != nil {
		log.Fatalf("logger.Setup err: %v", err)
	}
	encoder := zapcore.EncoderConfig{
		TimeKey:        "t",
		LevelKey:       "level",
		NameKey:        "logger",
		CallerKey:      "caller",
		MessageKey:     "msg",
		StacktraceKey:  "stack",
		EncodeTime:     zapcore.ISO8601TimeEncoder,
		LineEnding:     zapcore.DefaultLineEnding,
		EncodeLevel:    zapcore.LowercaseLevelEncoder,
		EncodeDuration: zapcore.SecondsDurationEncoder,
		EncodeCaller:   zapcore.FullCallerEncoder,
	}
	zipLevel := levelToZipLevel(level)
	core := zapcore.NewCore(
		zapcore.NewConsoleEncoder(encoder),
		zapcore.NewMultiWriteSyncer(
			zapcore.AddSync(os.Stdout),    //输出到控制台上
			zapcore.AddSync(rotateLogger), //输出到文本中
		), zipLevel)
	zapLogger := zap.New(core,
		zap.AddStacktrace(zap.NewAtomicLevelAt(zapcore.ErrorLevel)),
		zap.AddCaller(),
		zap.AddCallerSkip(2),
		zap.Development())
	return &FileLogger{
		log: zapLogger,
	}
}
func WithPrefix(logger *FileLogger, prefix ...interface{}) Logger {
	kvs := make([]interface{}, 0, len(logger.prefix)+len(prefix))
	kvs = append(kvs, logger.prefix...)
	kvs = append(kvs, prefix...)
	return &FileLogger{
		log:    logger.log,
		prefix: kvs,
	}
}
func levelToZipLevel(level Level) zapcore.Level {
	switch level {
	case Info:
		return zapcore.InfoLevel
	case Error:
		return zapcore.ErrorLevel
	case Debug:
		return zapcore.DebugLevel
	case Warn:
		return zapcore.WarnLevel
	case Fatal:
		return zapcore.FatalLevel
	default:
		return zapcore.InfoLevel
	}
}

func (f FileLogger) Info(i ...interface{}) {
	f.InfoW(Info, i...)
}
func (f FileLogger) Error(i ...interface{}) {
	f.InfoW(Error, i...)
}

func (f FileLogger) Debug(i ...interface{}) {
	f.InfoW(Debug, i...)
}

func (f FileLogger) Warn(i ...interface{}) {
	f.InfoW(Warn, i...)
}

func (f FileLogger) Fatal(i ...interface{}) {
	f.InfoW(Fatal, i...)
}

    func InitRouters(
	account *service.AccountServer,
	logger logger.Logger,
    ) *gin.Engine {
        mdls := []gin.HandlerFunc{middleware.LoggerMiddleware(logger)}
        mdls = append(mdls, middleware.AppMiddleware...)
        r := initGin(mdls...)

        // add api ping
        r.GET("ping", func(c *gin.Context) {
            c.JSON(200, gin.H{"msg": "this is ping", "timestamp": time.Now().Unix()})
        })

        r.POST("/login", account.Login)
        return r
    }

	fileLogger := logger.WithPrefix(logger.NewFileLogger(logger.Info),
		"service.id", Id,
		"service.name", Name,
		"service.version", Version,
	)

	s, err := wireApp(config.Server, fileLogger)

type AccountServer struct {
	logger logger.Logger
}

func NewAccountServer(logger logger.Logger) *AccountServer {
	return &AccountServer{
		logger: logger,
	}
}

func (a *AccountServer) Login(ctx *gin.Context) {
	a.logger.Info("msg", "this is login api")

	ctx.JSON(200, gin.H{
		"msg": "this is login api",
	})
}