beego的日志处理支持多种引擎、多种日志级别的输出，也可以设置输出方式（包括是否输出文件名和行号、同步输出或者异步输出等）。
本文将主要介绍一下beego是如何实现控制台和文件两个引擎的日志输出、日志消息如何构造以及如何实现的异步日志传输。
安装与使用
使用以下命令进行安装：
$ go get github.com/astaxie/beego/logs
安装后在源文件中引入包便可以使用了：
import ( "github.com/astaxie/beego/logs" )
输出引擎
注册引擎
beego支持的引擎有：console、file等，具体如下：
// Name for adapter with beego official support
const (
AdapterConsole = "console"
AdapterFile = "file"
AdapterMultiFile = "multifile"
AdapterMail = "smtp"
AdapterConn = "conn"
AdapterEs = "es"
AdapterJianLiao = "jianliao"
AdapterSlack = "slack"
AdapterAliLS = "alils"
)
每个引擎都需要实现以下接口：
// Logger defines the behavior of a log provider.
type Logger interface {
Init(config string) error
WriteMsg(when time.Time, msg string, level int) error
Destroy()
Flush()
}
全局变量adapters是一个map，关联了每个引擎的名称以及其对应的创建接口。每个引擎的源文件中都会有一个init() 函数，引入"github.com/astaxie/beego/logs"包时系统会自动调用该函数，该函数会将引擎的创建接口（NewConsole、newFileWriter）注册到adapters中。
var adapters = make(map[string]newLoggerFunc)
type newLoggerFunc func() Logger
func Register(name string, log newLoggerFunc) {
adapters[name] = log
}
/* ------------------------ console.go -------------------------- */
func init() {
Register(AdapterConsole, NewConsole)
}
// NewConsole create ConsoleWriter returning as LoggerInterface.
func NewConsole() Logger {
... ...
return cw
}
/* ------------------------ file.go -------------------------- */
func init() {
Register(AdapterFile, newFileWriter)
}
// newFileWriter create a FileLogWriter returning as LoggerInterface.
func newFileWriter() Logger {
w := &fileLogWriter{
... ...
}
return w
}
创建日志模块BeeLogger
logs模块创建了一个全局变量beeLogger，默认使用控制台输出日志：
var beeLogger = NewLogger()
func NewLogger(channelLens ...int64) *BeeLogger {
bl := new(BeeLogger)
... ...
bl.setLogger(AdapterConsole)
return bl
}
type BeeLogger struct {
lock sync.Mutex
level int
init bool
enableFuncCallDepth bool
loggerFuncCallDepth int
asynchronous bool
msgChanLen int64
msgChan chan *logMsg
signalChan chan string
wg sync.WaitGroup
outputs []*nameLogger
}
控制台引擎
创建控制台引擎，输出设置为os.Stdout，即控制台：
/* ------------------------ console.go -------------------------- */
// consoleWriter implements LoggerInterface and writes messages to terminal.
type consoleWriter struct {
lg *logWriter
Level int `json:"level"`
Colorful bool `json:"color"` //this filed is useful only when system's terminal supports color
}
// NewConsole create ConsoleWriter returning as LoggerInterface.
func NewConsole() Logger {
cw := &consoleWriter{
lg: newLogWriter(os.Stdout), // 输出设置为os.Stdout，即控制台
Level: LevelDebug,
Colorful: runtime.GOOS != "windows",
}
return cw
}
/* ------------------------ logger.go -------------------------- */
type logWriter struct {
sync.Mutex
writer io.Writer
}
func newLogWriter(wr io.Writer) *logWriter {
return &logWriter{writer: wr}
}
默认使用控制台引擎，日志级别包括：
/* ------------------------ log.go -------------------------- */
const (
LevelEmergency = iota
LevelAlert
LevelCritical
LevelError
LevelWarning
LevelNotice
LevelInformational
LevelDebug
)
默认使用LevelDebug级别：
/* ------------------------ log.go -------------------------- */
func NewLogger(channelLens ...int64) *BeeLogger {
bl := new(BeeLogger)
bl.level = LevelDebug
... ...
return bl
}
可以通过SetLevel函数设置输出级别，那么超出所设置级别的日志将不输出：
/* ------------------------ log.go -------------------------- */
func SetLevel(l int) {
beeLogger.SetLevel(l)
}
func (bl *BeeLogger) SetLevel(l int) {
bl.level = l
}
我们可以使用以下方法记录不同级别的日志：
logs.Debug("... ...")
logs.Warn("... ...")
logs.Notice("... ...")
... ...
以Debug为例，若是设置的日志级别低于LevelDebug，则不输出日志到控制台，直接返回；否则构造日志内容，并输出日志到控制台：
/* ------------------------ log.go -------------------------- */
func Debug(f interface{}, v ...interface{}) {
beeLogger.Debug(formatLog(f, v...))
// formatLog(f, v...)使日志支持格式化输出logs.Debug("xxx %v", xxx)
}
func (bl *BeeLogger) Debug(format string, v ...interface{}) {
if LevelDebug > bl.level { // 若是设置的日志级别低于LevelDebug，则不输出日志到控制台，直接返回
return
}
bl.writeMsg(LevelDebug, format, v...)
}
构造日志内容
通过以下设置，可以在每条日志之前加上哪个文件中哪一行调用的logs.Debug()函数：
/* ------------------------ 程序员的源文件 -------------------------- */
log.EnableFuncCallDepth(true)
log.SetLogFuncCallDepth(3)
/* ------------------------ log.go -------------------------- */
func EnableFuncCallDepth(b bool) {
beeLogger.enableFuncCallDepth = b
}
func SetLogFuncCallDepth(d int) {
beeLogger.loggerFuncCallDepth = d
}
根据设置构造日志内容：
/* ------------------------ log.go -------------------------- */
func (bl *BeeLogger) writeMsg(logLevel int, msg string, v ...interface{}) error {
... ...
when := time.Now() // 当前时间
if bl.enableFuncCallDepth {
_, file, line, ok := runtime.Caller(bl.loggerFuncCallDepth) // 获取文件名（包括路径）和行号
... ...
_, filename := path.Split(file) // 只取文件名
msg = "[" + filename + ":" + strconv.Itoa(line) + "] " + msg // 在日志前加上“[文件名：行号] ”字符串
}
... ...
msg = levelPrefix[logLevel] + msg // 在日志前加上“[D] ”字符串
... ...
bl.writeToLoggers(when, msg, logLevel)
... ...
return nil
}
var levelPrefix = [LevelDebug + 1]string{"[M] ", "[A] ", "[C] ", "[E] ", "[W] ", "[N] ", "[I] ", "[D] "}
func (bl *BeeLogger) writeToLoggers(when time.Time, msg string, level int) {
... ...
l.WriteMsg(when, msg, level)
... ...
}
日志颜色设置
console.go文件中有一个全局变量colors，这是一个数组，每个元素是一个brush函数，用于为日志内容渲染颜色：
/* ------------------------ console.go -------------------------- */
// brush is a color join function
type brush func(string) string
// newBrush return a fix color Brush
func newBrush(color string) brush {
pre := "\033["
reset := "\033[0m"
return func(text string) string {
return pre + color + "m" + text + reset
}
}
var colors = []brush{
newBrush("1;37"), // Emergency white
newBrush("1;36"), // Alert cyan
newBrush("1;35"), // Critical magenta
newBrush("1;31"), // Error red
newBrush("1;33"), // Warning yellow
newBrush("1;32"), // Notice green
newBrush("1;34"), // Informational blue
newBrush("1;44"), // Debug Background blue
}
/*
格式：\033[显示方式;前景色;背景色m
说明：
前景色 背景色 颜色
---------------------------------------
30 40 黑色
31 41 红色
32 42 绿色
33 43 黃色
34 44 蓝色
35 45 紫红色
36 46 青蓝色
37 47 白色
显示方式 意义
-------------------------
0 终端默认设置
1 高亮显示
4 使用下划线
5 闪烁
7 反白显示
8 不可见
例子：
\033[1;31;40m
\033[0m
*/
为日志渲染颜色：
/* ------------------------ console.go -------------------------- */
func (c *consoleWriter) WriteMsg(when time.Time, msg string, level int) error {
... ...
msg = colors[level](msg)
// 假设level为LevelDebug，则colors[level]得到newBrush("1;44")，
// 也就是函数func(text string) string { return "\033[1;44m" + text + "\033[0m" }
// 也就是日志内容渲染为高亮背景颜色为蓝色
... ...
c.lg.println(when, msg)
return nil
}
日志输出
以下函数先将当前时间格式化成"yyyy/mm/dd hh:mm:ss"格式，然后再构造成"yyyy/mm/dd hh:mm:ss msg\n"的格式，至此日志内容构造完成，调用Write输出。
/* ------------------------ logger.go -------------------------- */
func (lg *logWriter) println(when time.Time, msg string) {
lg.Lock()
// 竞争锁
h, _ := formatTimeHeader(when)
// 将时间格式化成"yyyy/mm/dd hh:mm:ss "格式
lg.writer.Write(append(append(h, msg...), '\n'))
// lg.writer为os.Stdout，则为os.Stdout.Write("yyyy/mm/dd hh:mm:ss msg\n")
lg.Unlock()
}
Debug、Informational、Notice、Warning、Error
文件引擎
创建文件引擎，输出到文件中，默认日志级别为LevelTrace，每天更换一个日志文件，日志文件保存最近7天的日志：
/* ------------------------ file.go -------------------------- */
type fileLogWriter struct {
sync.RWMutex // write log order by order and atomic incr maxLinesCurLines and maxSizeCurSize
// The opened file
Filename string `json:"filename"`
fileWriter *os.File
// Rotate at line
MaxLines int `json:"maxlines"`
maxLinesCurLines int
// Rotate at size
MaxSize int `json:"maxsize"`
maxSizeCurSize int
// Rotate daily
Daily bool `json:"daily"`
MaxDays int64 `json:"maxdays"`
dailyOpenDate int
dailyOpenTime time.Time
Rotate bool `json:"rotate"`
Level int `json:"level"`
Perm string `json:"perm"`
RotatePerm string `json:"rotateperm"`
fileNameOnly, suffix string // like "project.log", project is fileNameOnly and .log is suffix
}
// newFileWriter create a FileLogWriter returning as LoggerInterface.
func newFileWriter() Logger {
w := &fileLogWriter{
Daily: true,
MaxDays: 7,
Rotate: true,
RotatePerm: "0440",
Level: LevelTrace,
Perm: "0660",
}
return w
}
设置文件引擎
beego支持将日志写入到文件中，可以根据需要设置日志级别，设置文件路径、文件名，可以设置多少行、多少字节将日志重新写到另外一个日志文件，还可以设置每天分割一次日志文件并设置日志保存的天数：
logs.SetLogger(logs.AdapterFile,`{"filename":"log/project.log","level":7,"maxlines":0,"maxsize":0,"daily":true,"maxdays":10}`)
// "filename":"log/project.log" ：将日志保存到当前目录下的log目录下的project.log文件中
// "level":7 ：将日志级别设为7，也就是LevelDebug
// "maxlines":0 ：设置日志文件分割条件，若文件超过maxlines，则将日志保存到下个文件中，为0表示不设置
// "maxsize":0 ：设置日志文件分割条件，若文件超过maxsize，则将日志保存到下个文件中，为0表示不设置
// "daily":true：设置日志日否每天分割一次
// "maxdays":10：设置保存最近几天的日志文件，超过天数的日志文件被删除，为0表示不设置
/* ------------------------ log.go -------------------------- */
func SetLogger(adapter string, config ...string) error {
return beeLogger.SetLogger(adapter, config...)
}
func (bl *BeeLogger) SetLogger(adapterName string, configs ...string) error {
bl.lock.Lock()
// 设置之前需要加锁
defer bl.lock.Unlock()
... ...
return bl.setLogger(adapterName, configs...)
}
func (bl *BeeLogger) setLogger(adapterName string, configs ...string) error {
config := append(configs, "{}")[0]
... ...
log, ok := adapters[adapterName]
// adapters[adapterName]返回的是一个引擎的创建接口，这里为func newFileWriter() Logger
... ...
lg := log()
// 调用func newFileWriter() Logger，返回一个fileLogWriter文件引擎对象
err := lg.Init(config)
// 每个引擎对象都实现了Init函数
... ...
return nil
}
/* ------------------------ file.go -------------------------- */
func (w *fileLogWriter) Init(jsonConfig string) error {
err := json.Unmarshal([]byte(jsonConfig), w)
// jsonConfig是json格式的字符串，Unmarshal方法将其中的字段转化为对象w的字段
... ...
w.suffix = filepath.Ext(w.Filename)
// 取出后缀：.log
w.fileNameOnly = strings.TrimSuffix(w.Filename, w.suffix)
// 去除后缀：log/project
if w.suffix == "" {
w.suffix = ".log"
}
// 如果设置的文件后缀为空，则后缀设为".log"
err = w.startLogger()
return err
}
// start file logger. create log file and set to locker-inside file writer.
func (w *fileLogWriter) startLogger() error {
file, err := w.createLogFile()
// 打开文件log/project.log并返回其文件描述符
... ...
w.fileWriter = file
return w.initFd()
}
func (w *fileLogWriter) createLogFile() (*os.File, error) {
// Open the log file
perm, err := strconv.ParseInt(w.Perm, 8, 64)
// 将设置的文件权限转化为8进制，64位的整数
... ...
fd, err := os.OpenFile(w.Filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, os.FileMode(perm))
// 以只写权限并追加写的方式打开文件（log/project.log），如果文件不存在则创建文件
... ...
os.Chmod(w.Filename, os.FileMode(perm))
// 确保文件权限为设置的值
... ...
return fd, err
}
func (w *fileLogWriter) initFd() error {
fd := w.fileWriter
fInfo, err := fd.Stat()
... ...
w.maxSizeCurSize = int(fInfo.Size())
// 获取文件当前大小
w.dailyOpenTime = time.Now()
// 获取当前时间
w.dailyOpenDate = w.dailyOpenTime.Day()
// 获取文件打开时间
w.maxLinesCurLines = 0
if w.Daily {
go w.dailyRotate(w.dailyOpenTime)
// 创建一个线程处理日志文件按天分割工作
}
if fInfo.Size() > 0 {
count, err := w.lines()
... ...
w.maxLinesCurLines = count
// 获取文件当前行数
}
return nil
}
日志文件分割
beego用一个专门的goroutine来处理日志文件分割：
/* ------------------------ file.go -------------------------- */
func (w *fileLogWriter) dailyRotate(openTime time.Time) {
y, m, d := openTime.Add(24 * time.Hour).Date()
nextDay := time.Date(y, m, d, 0, 0, 0, 0, openTime.Location())
tm := time.NewTimer(time.Duration(nextDay.UnixNano() - openTime.UnixNano() + 100))
// 设置定时器，定时在24小时（也就是一天）之后，会给chan变量tm发送信号
<-tm.C
// 定时器到期，接收到信号
w.Lock()
if w.needRotate(0, time.Now().Day()) {
if err := w.doRotate(time.Now()); err != nil {
fmt.Fprintf(os.Stderr, "FileLogWriter(%q): %s\n", w.Filename, err)
}
}
w.Unlock()
}
func (w *fileLogWriter) needRotate(size int, day int) bool {
// 如果设置了最大行数或最大字节数，是否超过了设置值
// 如果按天分割，时间是否过了文件打开当天
// 满足一个以上条件则返回true
return (w.MaxLines > 0 && w.maxLinesCurLines >= w.MaxLines) ||
(w.MaxSize > 0 && w.maxSizeCurSize >= w.MaxSize) ||
(w.Daily && day != w.dailyOpenDate)
}
func (w *fileLogWriter) doRotate(logTime time.Time) error {
// file exists
// Find the next available number
num := 1
fName := ""
rotatePerm, err := strconv.ParseInt(w.RotatePerm, 8, 64)
... ...
if w.MaxLines > 0 || w.MaxSize > 0 {
// 若设置了最大行数或者最大字节数，则将日志文件名称设置成格式
// "project.yyyy-mm-dd.nnn.log"，nnn从001-999，最多一天有999个日志文件
for ; err == nil && num <= 999; num++ {
fName = w.fileNameOnly + fmt.Sprintf(".%s.%03d%s", logTime.Format("2006-01-02"), num, w.suffix)
_, err = os.Lstat(fName)
// 判断fName是否存在，若存在则返回nil
}
} else {
// 将日志文件名称设置成格式"project.yyyy-mm-dd.log"
fName = fmt.Sprintf("%s.%s%s", w.fileNameOnly, w.dailyOpenTime.Format("2006-01-02"), w.suffix)
_, err = os.Lstat(fName)
for ; err == nil && num <= 999; num++ {
fName = w.fileNameOnly + fmt.Sprintf(".%s.%03d%s", w.dailyOpenTime.Format("2006-01-02"), num, w.suffix)
_, err = os.Lstat(fName)
}
}
... ...
w.fileWriter.Close()
// 关闭当前日志文件，当前日志文件一直为project.log
err = os.Rename(w.Filename, fName)
// 将当前日志文件重命名为前面设置的格式fName
... ...
err = os.Chmod(fName, os.FileMode(rotatePerm))
startLoggerErr := w.startLogger()
// 再打开日志文件project.log，记录日志
go w.deleteOldLog()
// 开启新的线程处理文件删除工作
... ...
return nil
}
日志文件保存期限
beego允许用户设置日志文件保存天数，超高设置时间的日志文件将被删除，这个工作是由一个独立的goroutine处理的：
/* ------------------------ file.go -------------------------- */
func (w *fileLogWriter) deleteOldLog() {
dir := filepath.Dir(w.Filename)
filepath.Walk(dir, func(path string, info os.FileInfo, err error) (returnErr error) {
// 遍历目录dir下的所有文件
... ...
if !info.IsDir() && info.ModTime().Add(24*time.Hour*time.Duration(w.MaxDays)).Before(time.Now()) {
if strings.HasPrefix(filepath.Base(path), filepath.Base(w.fileNameOnly)) &&
strings.HasSuffix(filepath.Base(path), w.suffix) {
// 若一个文件有project前缀以及.log后缀，而且修改日期超过日志文件保存天数，则删除
os.Remove(path)
}
}
return
})
}
构造日志内容并输出到日志文件
文件引擎的日志内容构造与控制台日志内容构造差不多，以Debug为例，都是调用以下函数：
/* ------------------------ log.go -------------------------- */
func Debug(f interface{}, v ...interface{}) {
beeLogger.Debug(formatLog(f, v...))
// formatLog(f, v...)使日志支持格式化输出logs.Debug("xxx %v", xxx)
}
func (bl *BeeLogger) Debug(format string, v ...interface{}) {
if LevelDebug > bl.level { // 若是设置的日志级别低于LevelDebug，则不输出日志到控制台，直接返回
return
}
bl.writeMsg(LevelDebug, format, v...)
}
func (bl *BeeLogger) writeMsg(logLevel int, msg string, v ...interface{}) error {
... ...
when := time.Now() // 当前时间
if bl.enableFuncCallDepth {
_, file, line, ok := runtime.Caller(bl.loggerFuncCallDepth) // 获取文件名（包括路径）和行号
... ...
_, filename := path.Split(file) // 只取文件名
msg = "[" + filename + ":" + strconv.Itoa(line) + "] " + msg // 在日志前加上“[文件名：行号] ”字符串
}
... ...
msg = levelPrefix[logLevel] + msg // 在日志前加上“[D] ”字符串
... ...
bl.writeToLoggers(when, msg, logLevel)
... ...
return nil
}
var levelPrefix = [LevelDebug + 1]string{"[M] ", "[A] ", "[C] ", "[E] ", "[W] ", "[N] ", "[I] ", "[D] "}
func (bl *BeeLogger) writeToLoggers(when time.Time, msg string, level int) {
... ...
l.WriteMsg(when, msg, level)
... ...
}
所有引擎都实现了Logger接口，即实现了WriteMsg方法：
/* ------------------------ file.go -------------------------- */
func (w *fileLogWriter) WriteMsg(when time.Time, msg string, level int) error {
if level > w.Level { // 若日志级别超出设置的级别，则不输出
return nil
}
h, d := formatTimeHeader(when)
// 将时间格式化成"yyyy/mm/dd hh:mm:ss "格式
msg = string(h) + msg + "\n"
// 将日志内容格式化为"yyyy/mm/dd hh:mm:ss msg\n"格式
if w.Rotate {
// 判断是否需要分割日志文件并且是否达到分割要求，若是则分割
w.RLock()
if w.needRotate(len(msg), d) {
w.RUnlock()
w.Lock()
if w.needRotate(len(msg), d) {
if err := w.doRotate(when); err != nil {
fmt.Fprintf(os.Stderr, "FileLogWriter(%q): %s\n", w.Filename, err)
}
}
w.Unlock()
} else {
w.RUnlock()
}
}
w.Lock()
// 将日志写入文件之前需要竞争锁，如果有多个线程对日志文件进行写入操作，则会有竞争关系。这个问题在多线程应用中可能会成为性能瓶颈。
_, err := w.fileWriter.Write([]byte(msg))
// 将日志写入文件
if err == nil {
w.maxLinesCurLines++
w.maxSizeCurSize += len(msg)
}
w.Unlock()
return err
}
异步日志
beego日志默认使用同步日志写入的方式。前边控制台和文件引擎在日志写入前都需要对资源进行加锁，而且每次输出日志都需要调用系统调用，非常耗时，这导致在高并发的情况下会出现性能瓶颈。
异步日志是由一个专门的goroutine来将日志输出，调用日志输出的goroutine只需将日志内容通过信道发送给日志输出goroutine，日志输出goroutine会从信道中取出日志并输出。
信道大小默认为1000：
var beeLogger = NewLogger()
func NewLogger(channelLens ...int64) *BeeLogger {
bl := new(BeeLogger)
... ...
bl.msgChanLen = append(channelLens, 0)[0]
if bl.msgChanLen <= 0 {
bl.msgChanLen = defaultAsyncMsgLen
}
bl.signalChan = make(chan string, 1)
... ...
return bl
}
const defaultAsyncMsgLen = 1e3
设置异步日志输出
通过以下函数设置信道大小（2000），并触发异步日志输出：
/* ------------------------ 程序员的源文件 -------------------------- */
logs.Async(2000)
/* ------------------------ log.go -------------------------- */
func Async(msgLen ...int64) *BeeLogger {
return beeLogger.Async(msgLen...)
}
func (bl *BeeLogger) Async(msgLen ...int64) *BeeLogger {
bl.lock.Lock()
... ...
bl.asynchronous = true
// 触发异步日志输出
if len(msgLen) > 0 && msgLen[0] > 0 {
bl.msgChanLen = msgLen[0]
}
bl.msgChan = make(chan *logMsg, bl.msgChanLen)
// 设置信道大小
logMsgPool = &sync.Pool{
New: func() interface{} {
// 若从消息池中取日志时消息池为空，则调用该函数，返回一个logMsg的空接口
return &logMsg{}
},
}
bl.wg.Add(1)
// sync.WaitGroup只有3个方法，Add()，Done()，Wait()。
// 其中Done()是Add(-1)的别名。简单的来说，
// 使用Add()添加计数，Done()减掉一个计数，计数不为0, Wait()阻塞计数为0。
go bl.startLogger()
// 启动新的线程处理日志输出
return bl
}
// BeeLogger is default logger in beego application.
// it can contain several providers and log message into all providers.
type BeeLogger struct {
... ...
asynchronous bool
msgChanLen int64
msgChan chan *logMsg
signalChan chan string
wg sync.WaitGroup
}
type logMsg struct {
level int
msg string
when time.Time
}
var logMsgPool *sync.Pool
构造日志内容
以Debug为例，都是调用以下函数：
/* ------------------------ log.go -------------------------- */
func Debug(f interface{}, v ...interface{}) {
beeLogger.Debug(formatLog(f, v...))
// formatLog(f, v...)使日志支持格式化输出logs.Debug("xxx %v", xxx)
}
func (bl *BeeLogger) Debug(format string, v ...interface{}) {
if LevelDebug > bl.level { // 若是设置的日志级别低于LevelDebug，则不输出日志到控制台，直接返回
return
}
bl.writeMsg(LevelDebug, format, v...)
}
func (bl *BeeLogger) writeMsg(logLevel int, msg string, v ...interface{}) error {
... ...
when := time.Now() // 当前时间
if bl.enableFuncCallDepth {
_, file, line, ok := runtime.Caller(bl.loggerFuncCallDepth) // 获取文件名（包括路径）和行号
... ...
_, filename := path.Split(file) // 只取文件名
msg = "[" + filename + ":" + strconv.Itoa(line) + "] " + msg // 在日志前加上“[文件名：行号] ”字符串
}
... ...
msg = levelPrefix[logLevel] + msg // 在日志前加上“[D] ”字符串
... ...
if bl.asynchronous { // 异步日志输出
lm := logMsgPool.Get().(*logMsg)
// 从logMsgPool中获取一个logMsg对象
lm.level = logLevel
lm.msg = msg
lm.when = when
// 构造日志消息
bl.msgChan <- lm
// 将日志消息通过信道传输给日志输出goroutine
} else {
... ...
}
return nil
}
var levelPrefix = [LevelDebug + 1]string{"[M] ", "[A] ", "[C] ", "[E] ", "[W] ", "[N] ", "[I] ", "[D] "}
日志输出
异步日志输出由一个专门的线程处理：
func (bl *BeeLogger) startLogger() {
gameOver := false
for {
select {
case bm := <-bl.msgChan:
// 从信道中取出一个日志并输出到设置的引擎中
bl.writeToLoggers(bm.when, bm.msg, bm.level)
logMsgPool.Put(bm)
case sg := <-bl.signalChan:
// Now should only send "flush" or "close" to bl.signalChan
bl.flush()
if sg == "close" {
for _, l := range bl.outputs {
l.Destroy()
}
bl.outputs = nil
gameOver = true
}
bl.wg.Done()
}
if gameOver {
break
}
}
}
func (bl *BeeLogger) writeToLoggers(when time.Time, msg string, level int) {
... ...
err := l.WriteMsg(when, msg, level)
// 这里将msg输出到设置的引擎，这与前边同步日志输出中控制台输出和文件输出一样
... ...
}
至此，关于beego logs包中的控制台和文件输出的代码学习就结束了～其他引擎的学习大致也是如此，如果有兴趣可以再看看。