（1）go web开发之 zap日志库的使用及gin框架配置zap记录日志详细文档讲解分析

我是py呀

墨衍会员 · AI 创作全网分发码龄8年

关注

原创最新推荐文章于 2026-06-17 13:50:14 发布 2.6k 阅读 AI 写同款· GEO 优化 ›

日志库 —— Go Zap 入门本文通过丰富的代码示例演示了 zap 的基本功能，读者可以跟随这些示例，学习如何使用 zap。阅读详情

（一）介绍

zap 是go 中比较火的一个日志库，提供不同级别的日志，并且速度快
官方文档： https://pkg.go.dev/go.uber.org/zap#section-readme，也可以github 直接搜索 zap。文档上面有全面的介绍。鼓励大家观看文档，可以有视频资料做相关引导，但学东西必须要看到官方文档。尤其是文档也已经适合入门了，先看Quick Start 部分，一般都有入门例子及整体框架介绍。
官方文档介绍，非常清晰，还有相关数据对比，并且一般都会具有 example文件夹提供相关的编程实例。

Quick Start（快速开始）： zap提供了两种日志记录器：

（1）SugaredLogger：（加了糖的 Logger）

官方文档介绍：在性能很好但不是很关键的环境中，使用SugaredLogger。它比其他结构化日志包快4-10倍，并且包含结构化和printf风格的api。

// 创建一个 logger
logger, _ := zap.NewProduction()
defer logger.Sync() // flushes buffer, if any， 刷新缓冲区，存盘
sugar := logger.Sugar()
sugar.Infow("failed to fetch URL",
  // 结构化上下文为松散类型的键值对。
  "url", url,
  "attempt", 3,
  "backoff", time.Second,
)
sugar.Infof("Failed to fetch URL: %s", url)

（2）Logger

当性能和类型安全至关重要时，使用Logger。它甚至比SugaredLogger还要快，并且分配的数量要少得多，但是它只支持结构化日志 。

logger, _ := zap.NewProduction()
defer logger.Sync()
logger.Info("failed to fetch URL",
  // 作为强类型字段值的结构化上下文.
  zap.String("url", url),
  zap.Int("attempt", 3),
  zap.Duration("backoff", time.Second),
)

更多介绍可以看文档 choose a logger
- 在Logger和SugaredLogger之间进行选择不需要在应用程序范围内进行决定:在两者之间进行转换既简单又便宜。从上面就可以看出来，二者创建使用区别很小。
```
logger := zap.NewExample()
defer logger.Sync()
sugar := logger.Sugar()
plain := sugar.Desugar()
```

（二）讲解 zap

1. 日志级别

在 const 文档下面，有介绍日志级别的定义

const (
	// DebugLevel logs are typically voluminous, and are usually disabled in
	// production.
	DebugLevel = zapcore.DebugLevel
	// InfoLevel is the default logging priority.
	InfoLevel = zapcore.InfoLevel
	// WarnLevel logs are more important than Info, but don't need individual
	// human review.
	WarnLevel = zapcore.WarnLevel
	// ErrorLevel logs are high-priority. If an application is running smoothly,
	// it shouldn't generate any error-level logs.
	ErrorLevel = zapcore.ErrorLevel
	// DPanicLevel logs are particularly important errors. In development the
	// logger panics after writing the message.
	DPanicLevel = zapcore.DPanicLevel
	// PanicLevel logs a message, then panics.
	PanicLevel = zapcore.PanicLevel
	// FatalLevel logs a message, then calls os.Exit(1).
	FatalLevel = zapcore.FatalLevel
)

2. 构建 looger

在文档的 Configuring Zap中：
构建Logger最简单的方法是使用zap固有的预设:NewExample、NewProduction和NewDevelopment。这些预置用一个函数调用构建一个日志记录器。
三者创建的 logger 是有区别的，我们可以在官方文档的 type logger下面找到三个函数的介绍, 对应不同的场景。
- func NewExample(options ...Option) *Logger
  - NewExample构建了一个专门为zap的可测试示例设计的Logger。它将DebugLevel及以上的日志作为JSON写入标准输出，但省略了时间戳和调用函数，以保持示例输出的简短和确定性
- func NewProduction(options ...Option) (*Logger, error)
  - NewProduction构建了一个合理的生产日志记录器，它将infollevel及以上的日志以JSON的形式写入标准错误。
  - 它是NewProductionConfig(). build(…Option)的快捷方式。
- func NewDevelopment(options ...Option) (*Logger, error)
  - NewDevelopment构建一个开发日志记录器，它以人类友好的格式将DebugLevel及以上级别的日志写入标准错误。
  - 这是NewDevelopmentConfig().Build(…选项)的快捷方式
  - 就好比去商店卖商品，初上自带了几个配置好的模式。通过配置生成对应的 logger。我们也可以自定义配置，生成自己自定义的 logger。

3. 方法使用

在文档的 types/logger 和 types/SaguredLogger 里面记录了相关的looger记录消息的使用方法。

以logger为例子：
都接受一个 msg String，后面是可选的一些字段。Field 类型，可以查看文档有很多的类型。

写一个Get请求访问相应的网址，记录日志信息

package main

import (
	"net/http"
	"time"
	"go.uber.org/zap"
)

func main() {
	// 创建一个 logger, 可以选择其他预置创建，会有不同的输出效果
	logger, _ := zap.NewProduction()
	defer logger.Sync() // flushes buffer, if any， 刷新缓冲区，存盘
	// 定义url
	url := "http://www.baidu.com"
	resp, err := http.Get(url)
	// 直接出错日志
	if err != nil {
		logger.Error("访问失败了",
			zap.String("url", url),
			// 跟上错误信息
			zap.Error(err),
		)
	}else {
		// info 级别的日志信息打印
		logger.Info("成功访问！",
			// 作为强类型字段值的结构化上下文.
			zap.String("url", url),
			zap.String("status", resp.Status),
			zap.Duration("backoff", time.Second),
		)
		resp.Body.Close()
	}

}

结果分别为：

{"level":"info","ts":1637632861.812557,
"caller":"zap日志库学习/main.go:25",
"msg":"成功访问！",
"url":"http://www.baidu.com",
"status":"200 OK","backoff":1}

{"level":"error",
"ts":1637633063.4520404,
"caller":"zap日志库学习/main.go:18",
"msg":"访问失败了",
"url":"http://www.xxx.com",
"error":"Get \"http://www.xxx.com\": dial tcp 69.171.228.20:80: connectex: A connection attempt failed because the connected party did not properly respond after a p
eriod of time, or established connection failed because connected host has failed to respond.","stacktrace":"main.main\n\tD:/gofiles/go-learning
-notes/go-learning/zap日志库学习/main.go:18\nruntime.main\n\tD:/software/go/go1.15/src/runtime/proc.go:204"}

可以看到执行程序后终端提示相关的信心。 msg 就是自己设置的，时间， url等。还有一个 caller 调用者信息，指明问题出现的行数。

NewDevelopment() 创建的生成日志是这样的：空格隔开。缺少调用者

2021-11-23T10:08:26.171+0800    INFO    zap日志库学习/main.go:25        成功访问！     
 {"url": "http://www.baidu.com", "status": "200 OK", "backoff": "1s"}

NewExample()

{"level":"info","msg":"成功访问！","url":"http://www.baidu.com","status":"200 OK","backoff":"1s"}

4. 定制化 logger

查看NewProduction 的源码就能知道，实际底层就是： NewProductionConfig().Build(options...)
- 调用了 NewProductionConfig()方法，内部初始化创建，返回了一个 Config 对象。
- Build，内部通过 Config对象的配置，利用New方法生成相应的 logger对象，并返回。
- 也就是说，这是 zap库给我们预置的 NewProduction（）等方法，内部是按照指定的配置，生成相应的 logger 日志对象。我们也可以自己调用内部的相关方法，模仿 NewProductionConfig().Build(options…) 相关过程，自己创建，定制化 logger对象。
- 观察New方法 生成logger 所需要的东西。在Build 函数中：
```
// 返回一个 Core对象， 需要的是 三个参数
func NewCore(enc Encoder, ws WriteSyncer, enab LevelEnabler) Core
func New(core zapcore.Core, options ...Option) *Logger

log := New(
		zapcore.NewCore(enc, sink, cfg.Level),
		cfg.buildOptions(errSink)...,
	)
```
- 官方对 Core的介绍：需要打开对应的包，查看文档
  Core是一个最小的、快速的记录器接口。它是为库作者设计的，用来封装更友好的API。
关于 NewProductionConfig()函数，返回对应的Config 对象，Build 函数根据这个配置，进行生成 logger对象。

我们当然可以自定义这个，来实现生成自己的logger. 下面看下它的源码

// NewProductionConfig是一个合理的生产日志配置。
//在infollevel及以上级别启用日志记录。
//它使用JSON编码器，写入标准错误，并启用采样。
// stacktrace会自动包含在ErrorLevel及以上的日志中。
func NewProductionConfig() Config {
	return Config{
		// 日志级别
		Level:       NewAtomicLevelAt(InfoLevel),
		Development: false,
		Sampling: &SamplingConfig{
			Initial:    100,
			Thereafter: 100,
		},
		// 编码方式
		Encoding:         "json",
		// EncoderCofig， 配置 encoder 编辑器的默认配置。
		EncoderConfig:    NewProductionEncoderConfig(),
		// 打开的文件， 写入日志信息到这里。
		OutputPaths:      []string{"stderr"},
		ErrorOutputPaths: []string{"stderr"},
	}
}

（1）如何写入日志文件

按照上面的自定义 logger，创建核心Core需要三个参数，其中就有控制写入文件的。
Encoder： 编辑器。提供了两种信息的编辑方式。
- 需要传递的参数，可以使用默认的EncoderConfig: NewProductionEncoderConfig() 传递进去。
- 一种文本样式的，一种 json 样式的信息输入。
WriteSyncer： 指定日志写到哪里。可以定义自己指定的文件路径
- 通过func AddSync(w io.Writer) WriteSyncer 方法，返回一个。
  AddSync用于转换io。Writer到WriteSyncer。它试图是智能的:如果具体类型的io。Writer实现了WriteSyncer，我们将使用现有的Sync方法。如果没有，我们将添加一个无操作同步。
```
	// 创建文件对象
	file, _ := os.Create("./getLog.log")  // 或者是用 OpenFile函数，在原来基础上追加。
	// file, _ := os.OpenFile("./getLog.log", os.O_APPEND | os.O_RDWR, 0744)
	// 生成 WriteSyncer
	wSy := zapcore.AddSync(file)
```
LevelEnabler： 设置哪种级别的日志将被写入
- 对应的就是前面介绍的日志级别；如：
  zapcore.DebugLevel

创建自定义logger：

根据上面三点参数的理解，就可以指定文件建立了

// 还剩一个后面的配置信息没有传入，但是已经可以了
// 默认我们调用 NewProduction（）方法也是没有传递啥配置进去的。
log := New(
		zapcore.NewCore(传递编辑器（两种）, 自定义文件输出, cfg.Level（级别）),
		)

按照这样的建立完成之后就可以使用了，往指定文件里打印日志。

还有 zap 预置的生成 logger的方式，都是通过 NewProductionConfig() 来生成相关配置的，也可以不用这么麻烦，我觉得直接， 自定义一个 NewProductionConfig() 然后，按着相应的步骤就可以了。 Build方法就是通过配置的 Config 对象，来生成的 logger。
这里有个系列教程文章：https://blog.youkuaiyun.com/weixin_39620252/article/details/111136566

像我这样：重写方法，只需要加个文件名就可以了

func myNewProduction(options ...zap.Option) (*zap.Logger, error) {
	return myNewProductionConfig().Build(options...)
}

func myNewProductionConfig() zap.Config {
	config := zap.NewProductionConfig()
	// 配置输出路径为 ./test.log   其他都不变， 内部默认是 json 编码。 只要 json 和 console两种。可以看 Encoding 字段的介绍。
	config.OutputPaths = []string{"./test.log"}
	return config
}

// 创建logger 对象
logger, _ := myNewProduction()

（2）更改时间编码及添加调用者的详细信息

时间格式（或者说是编码）更改

时间显示这一块，我们可以看到，默认的 NewProductionConfig(）函数里创建的字段中的对 Encoder 消息编辑器对象的配置 EncoderConfig
在文档中也能找到它的描述： https://pkg.go.dev/go.uber.org/zap@v1.19.1/zapcore#EncoderConfig

func NewProductionEncoderConfig() zapcore.EncoderConfig {
	return zapcore.EncoderConfig{
		// 包含key的全部都是定义的输出字段名字。
		TimeKey:        "ts",
		LevelKey:       "level",
		NameKey:        "logger",
		CallerKey:      "caller",
		FunctionKey:    zapcore.OmitKey,
		MessageKey:     "msg",
		StacktraceKey:  "stacktrace",
		LineEnding:     zapcore.DefaultLineEnding,
		EncodeLevel:    zapcore.LowercaseLevelEncoder,
		EncodeTime:     zapcore.EpochTimeEncoder,
		EncodeDuration: zapcore.SecondsDurationEncoder,
		EncodeCaller:   zapcore.ShortCallerEncoder,
	}

我们顺着文档去找或者是直接点进去 EncodeTime: zapcore.EpochTimeEncoder。 EncodeTime 顾名思义：时间编码。就是这里控制的，点进去后，该函数下方还有好几个设置时间编码的函数，文档中也能找到。
那么我们可以直接修改对应的配置，满足我们的自定义要求。
- 选择 ISO8601TimeEncoder： “2006-01-02T15:04:05.000Z0700” 比较容易看懂的格式。
- 按照上面修改导入文件的方法：
```
func myNewProductionConfig() zap.Config {
	config := zap.NewProductionConfig()
	// 修改导入文件路径
	config.OutputPaths = []string{"./test.log"}
	// 修改时间格式：
	config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
	return config
}
```
  - 再次运行，时间编码就会改变
```
{"level":"info","ts":"2021-11-23T17:13:39.430+0800","caller":"zap日志库学习/main.go:43","msg":"成功访问！","url":"http://www.baidu.com","status":"200 OK","backoff":1}
```
- 我们这里的写法，还是不断的修改 NewProductionConfig() 为我们预置的配置。 如果想大改，创建自己的话，就一步步创建 Core 核心。然后重新定义自己的 NewProductionEncoderConfig()。

显示详细的添加调用者的详细信息。

根据时间的理解，这里很容易想到：配置项当中的 EncodeCaller，也可以指定相关的函数，用来打印调用者的信息。
还有一种方式是：我们创建Core, zap.New()创建 logger, 分析第二个参数的 Options 类型，文档中可以找到相关的方法，就有添加调试显示调用人信息的方法。
```
func New(core zapcore.Core, options ...Option) *Logger
log := zap.New(
		zapcore.NewCore(enc, sink, cfg.Level),
		zap.AddCaller(),
	)
```

在这里插入图片描述

5. Lumberjack 进行日志文件的切割归档

这部分就比较难了，没有实际操作过，就不懂。参考文章或者相关视频，二者结合使用。
日志存的多的话，日志文件越来越大，几个G的话，打开和操作就太麻烦了！那么就需要对日志文件进行分割，归档。
需要安装第三方库：Lumberjack： go get -u github.com/natefinch/lumberjack
使用时仍然是打开文件，配合 zap使用，需要创建新的 zapcore.WriteSyncer。

lumberjack.Logger 实现了 io.writer 接口，可以作为参数。

func getLogWriter() zapcore.WriteSyncer {
	lumberJackLogger := &lumberjack.Logger{
		Filename: "./test.log",  // 导入文件名
		MaxSize: 10, // 大小M兆
		MaxBackups: 5,  // 最大备份数量
		MaxAge: 30,		// 最大备份天数
		Compress: false,  // 是否压缩
	}
	return zapcore.AddSync(lumberJackLogger)
}

进行测试：

// 创建新的logger对象
encoder := zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
writeSyncer := getLogWriter()
// 创建核心
newCore := zapcore.NewCore(encoder, writeSyncer, zapcore.InfoLevel)
// 创建logger
logger := zap.New(newCore)
// 插入日志
for i := 0; i < 10000; i++ {
	logger.Info("成功访问！",
		// 作为强类型字段值的结构化上下文.
		zap.String("url", "测试归档"),
		zap.String("status", "添加数据"),
		zap.Duration("backoff", time.Second),
	)
}
defer logger.Sync() // flushes buffer, if any， 刷新缓冲区，存盘

效果展示：以当前时间戳建立新文件
归档文件中有八万多数据
test.log 中只有： 3000多条

6. gin框架中配置zap记录日志

在上一篇文章中：《详细讲解go web框架之gin框架源码解析记录及思路流程和理解》
- 讲解了 gin.Default 创建引擎，默认的添加了两个中间件。一个是 logger 日志，一个是 recover 恢复。 gin 自带的 logger 就是在这里实现起作用的。
  - 那么我们也需要将 zap封装为 logger 中间件（HandlerFunc）。
  - 具体实现可以参考给出的两个 logger recover 中间件的实现，加以修改。
下面进行实际讲解， logger，recover 可以自己实现，也有现成的：https://github.com/gin-contrib/zap/blob/master/zap.go#L3

yaml格式的配置文件：

app:
  name: "web_app"
  # 开发模式
  mode: "dev"
  port: 8080


log:
  level: "debug"
  filename: "web_app.log"
  # 最大存储大小
  max_size: 200
  # 最大存储时间
  max_age: 30
  # 备份数量
  max_backups: 7

实现logger：

1.自定义logger对象
2.自定义（模仿原来的logger，recover）实现这俩中间件
其中要注意的是viper 读取配置文件，这是在下一节讲的：https://blog.youkuaiyun.com/pythonstrat/article/details/121513996
其中：UnmarshalText函数，读取配置中的文本信息，转换为日志级别类型。
- 需要首先定义一个日志级别类型的指针，后UnmarshalText函数将赋值进去。

package logger

import (
	"github.com/gin-gonic/gin"
	"github.com/natefinch/lumberjack"
	"github.com/spf13/viper"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"net"
	"net/http"
	"net/http/httputil"
	"os"
	"runtime/debug"
	"strings"
	"time"
)


// 初始化Logger
func Init() (err error) {
	// 创建Core三大件，进行初始化
	writeSyncer := getLogWriter(
		viper.GetString("log.filename"),
		viper.GetInt("log.max_size"),
		viper.GetInt("log.max_backups"),
		viper.GetInt("log.max_age"),
		)
	encoder := getEncoder()
	// 定义一个日志级别类型指针
	var l = new(zapcore.Level)
	// 将 yaml 配置文件中的 表示级别的文本，转换为 相应的 级别类型，赋值给 创建的指针
	err = l.UnmarshalText([]byte(viper.GetString("log.level")))
	if err != nil {
		return
	}
	// 创建核心
	core := zapcore.NewCore(encoder, writeSyncer, l)
	// 创建 logger 对象
	log := zap.New(core, zap.AddCaller())
	// 替换全局的 logger, 后续在其他包中只需使用zap.L()调用即可
	zap.ReplaceGlobals(log)
	return
}


func getEncoder() zapcore.Encoder {
	// 使用zap提供的 NewProductionEncoderConfig
	encoderConfig := zap.NewProductionEncoderConfig()
	// 设置时间格式
	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
	// 时间的key
	encoderConfig.TimeKey = "time"
	// 级别
	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
	// 显示调用者信息
	encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
	// 返回json 格式的 日志编辑器
	return zapcore.NewJSONEncoder(encoderConfig)
}


func getLogWriter(filename string, maxSize, maxBackup, maxAge int) zapcore.WriteSyncer {
	// 使用 lumberjack 归档切片日志
	lumberJackLogger := &lumberjack.Logger{
		Filename:   filename,
		MaxSize:    maxSize,
		MaxBackups: maxBackup,
		MaxAge:     maxAge,
	}
	return zapcore.AddSync(lumberJackLogger)
}


// GinLogger 接收gin框架默认的日志
func GinLogger() gin.HandlerFunc {
	logger := zap.L()
	return func(c *gin.Context) {
		start := time.Now()
		path := c.Request.URL.Path
		query := c.Request.URL.RawQuery
		c.Next()

		cost := time.Since(start)
		logger.Info(path,
			zap.Int("status", c.Writer.Status()),
			zap.String("method", c.Request.Method),
			zap.String("path", path),
			zap.String("query", query),
			zap.String("ip", c.ClientIP()),
			zap.String("user-agent", c.Request.UserAgent()),
			zap.String("errors", c.Errors.ByType(gin.ErrorTypePrivate).String()),
			zap.Duration("cost", cost),
		)
	}
}


// GinRecovery
func GinRecovery(stack bool) gin.HandlerFunc {
	logger := zap.L()
	return func(c *gin.Context) {
		defer func() {
			if err := recover(); err != nil {
				// Check for a broken connection, as it is not really a
				// condition that warrants a panic stack trace.
				var brokenPipe bool
				if ne, ok := err.(*net.OpError); ok {
					if se, ok := ne.Err.(*os.SyscallError); ok {
						if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
							brokenPipe = true
						}
					}
				}

				httpRequest, _ := httputil.DumpRequest(c.Request, false)
				if brokenPipe {
					logger.Error(c.Request.URL.Path,
						zap.Any("error", err),
						zap.String("request", string(httpRequest)),
					)
					// If the connection is dead, we can't write a status to it.
					c.Error(err.(error)) // nolint: errcheck
					c.Abort()
					return
				}

				if stack {
					logger.Error("[Recovery from panic]",
						zap.Any("error", err),
						zap.String("request", string(httpRequest)),
						zap.String("stack", string(debug.Stack())),
					)
				} else {
					logger.Error("[Recovery from panic]",
						zap.Any("error", err),
						zap.String("request", string(httpRequest)),
					)
				}
				c.AbortWithStatus(http.StatusInternalServerError)
			}
		}()
		c.Next()
	}
}

7. gin中使用日志的补充

我们上面代码生成的核心，默认的级别以及是向文件中进行输出的。那么我们在生产环境中的时候，就会很不方便查看日志的信息。解决办法，可以定义一个 mode string 类型的参数。根据需要去创建 core满足，在控制台输出的需求。

更改上述代码中创爱核心的操：

// 新增： 根据 mode 参数创建
	var core zapcore.Core
	if mode == "dev" {
		// 开发模式，日志输出到终端
		consoleEncoder := zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig())
		// NewTee创建一个核心，将日志条目复制到两个或多个底层核心中。
		core = zapcore.NewTee(
			zapcore.NewCore(encoder, writeSyncer, l),
			zapcore.NewCore(consoleEncoder, zapcore.Lock(os.Stdout), zapcore.DebugLevel),
		)
	} else {
		// 创建核心
		core = zapcore.NewCore(encoder, writeSyncer, l)
	}

这里面我们上面讲过json 形式的日志，还有就是 zapcore.NewConsoleEncoder想控制台打印信息。使用的也是默认自带的配置。
其中zap的 zapcore.NewTee方法，可以支持多个核心。像上面这样日志既会正常的在文件中写入，还会在终端中打印。

另外对于 gin 日志的相关，gin文档中也有相关的描述：

写日志文件： https://www.kancloud.cn/shuangdeyu/gin_book/949424

func main() {
    // 禁用控制台颜色
    gin.DisableConsoleColor()

    // 创建记录日志的文件
    f, _ := os.Create("gin.log")
    gin.DefaultWriter = io.MultiWriter(f)

    // 如果需要将日志同时写入文件和控制台，请使用以下代码
    // gin.DefaultWriter = io.MultiWriter(f, os.Stdout)

    router := gin.Default()
    router.GET("/ping", func(c *gin.Context) {
        c.String(200, "pong")
    })

    router.Run(":8080")
}

写日志文件里有对上面定义的： os.Stdout的描述，但是zap里不能直接使用，还要通过 Lock（） 函数进行类型转换下。

自定义日志格式：https://www.kancloud.cn/shuangdeyu/gin_book/949425

另外 gin 默认的是debug 模式，会输出一些信息在终端：
也提示我们如果要在生产环境中可以通过两种方式实现，第二种是在程序中，创建 engine 实例之前调用就行了。

下面是 gin源码里的三种模式常量

const (
	// DebugMode indicates gin mode is debug.
	DebugMode = "debug"
	// ReleaseMode indicates gin mode is release.
	ReleaseMode = "release"
	// TestMode indicates gin mode is test.
	TestMode = "test"
)