Golang 语言的标准库 log 包怎么使用?

开发 前端
Golang 语言的标准库中提供了一个简单的 log 日志包,它不仅提供了很多函数,还定义了一个包含很多方法的类型 Logger。但是它也有缺点,比如不支持区分日志级别,不支持日志文件切割等。

01、介绍

Golang 语言的标准库中提供了一个简单的 log 日志包,它不仅提供了很多函数,还定义了一个包含很多方法的类型 Logger。但是它也有缺点,比如不支持区分日志级别,不支持日志文件切割等。

[[379196]]

02、函数

Golang 的 log 包主要提供了以下几个具备输出功能的函数:

 

  1. func Fatal(v ...interface{})  
  2. func Fatalf(format string, v ...interface{})  
  3. func Fatalln(v ...interface{})  
  4. func Panic(v ...interface{})  
  5. func Panicf(format string, v ...interface{})  
  6. func Panicln(v ...interface{})  
  7. func Print(v ...interface{})  
  8. func Printf(format string, v ...interface{})  
  9. func Println(v ...interface{}) 

这些函数的使用方法和 fmt 包完全相同,通过查看源码可以发现,Fatal[ln|f] 和 Panic[ln|f] 实际上是调用的 Print[ln|f],而 Print[ln|f] 实际上是调用的 Output() 函数。

其中 Fatal[ln|f] 是调用 Print[ln|f] 之后,又调用了 os.Exit(1) 退出程序。

其中 Panic[ln|f] 是调用 Panic[ln|f] 之后,又调用了 panic() 函数,抛出一个恐慌。

所以,我们很有必要阅读一下 Output() 函数的源码。

函数 Output() 的源码:

  1. func (l *Logger) Output(calldepth int, s string) error { 
  2.  now := time.Now() // get this early. 
  3.  var file string 
  4.  var line int 
  5.  l.mu.Lock() 
  6.  defer l.mu.Unlock() 
  7.  if l.flag&(Lshortfile|Llongfile) != 0 { 
  8.   // Release lock while getting caller info - it's expensive. 
  9.   l.mu.Unlock() 
  10.   var ok bool 
  11.   _, file, line, ok = runtime.Caller(calldepth) 
  12.   if !ok { 
  13.    file = "???" 
  14.    line = 0 
  15.   } 
  16.   l.mu.Lock() 
  17.  } 
  18.  l.buf = l.buf[:0] 
  19.  l.formatHeader(&l.buf, now, file, line) 
  20.  l.buf = append(l.buf, s...) 
  21.  if len(s) == 0 || s[len(s)-1] != '\n' { 
  22.   l.buf = append(l.buf, '\n'
  23.  } 
  24.  _, err := l.out.Write(l.buf) 
  25.  return err 

通过阅读 Output() 函数的源码,可以发现使用互斥锁来保证多个 goroutine 写日志的安全,并且在调用 runtime.Caller() 函数之前,先释放互斥锁,获取到信息后再加上互斥锁来保证安全。

使用 formatHeader() 函数来格式化日志的信息,然后保存到 buf 中,然后再把日志信息追加到 buf 的末尾,然后再通过判断,查看日志是否为空或末尾不是 \n,如果是就再把 \n 追加到 buf 的末尾,最后将日志信息输出。

函数 Output() 的源码也比较简单,其中最值得注意的是 runtime.Caller() 函数,源码如下:

  1. func Caller(skip int) (pc uintptr, file string, line int, ok bool) { 
  2.  rpc := make([]uintptr, 1) 
  3.  n := callers(skip+1, rpc[:]) 
  4.  if n < 1 { 
  5.   return 
  6.  } 
  7.  frame, _ := CallersFrames(rpc).Next() 
  8.  return frame.PC, frame.File, frame.Line, frame.PC != 0 

通过阅读 runtime.Caller() 函数的源码,可以发现它接收一个 int 类型的参数 skip,该参数表示跳过栈帧数,log 包中的输出功能的函数,使用的默认值都是 2,原因是什么?

举例说明,比如在 main 函数中调用 log.Print,方法调用栈为 main->log.Print->*Logger.Output->runtime.Caller,所以此时参数 skip 的值为 2,表示 main 函数中调用 log.Print 的源文件和代码行号;

参数值为 1,表示 log.Print 函数中调用 *Logger.Output 的源文件和代码行号;参数值为 0,表示 *Logger.Output 函数中调用 runtime.Caller 的源文件和代码行号。

至此,我们发现 log 包的输出功能的函数,全部都是把信息输出到控制台,那么该怎么将信息输出到文件中呢?

函数 SetOutPut 就是用来设置输出目标的,源码如下:

  1. func SetOutput(w io.Writer) { 
  2.  std.mu.Lock() 
  3.  defer std.mu.Unlock() 
  4.  std.out = w 

我们可以通过函数 os.OpenFile 来打开一个用于 I/O 的文件,返回值作为函数 SetOutput 的参数。

除此之外,读者应该还发现了一个问题,输出信息都是以日期和时间开头,我们该怎么记录更加丰富的信息呢?比如源文件和行号。

这就用到了函数 SetFlags,它可以设置输出的格式,源码如下:

  1. func SetFlags(flag int) { 
  2.  std.SetFlags(flag) 

参数 flag 的值可以是以下任意常量:

  1. const ( 
  2.  Ldate         = 1 << iota     // the date in the local time zone: 2009/01/23 
  3.  Ltime                         // the time in the local time zone: 01:23:23 
  4.  Lmicroseconds                 // microsecond resolution: 01:23:23.123123.  assumes Ltime. 
  5.  Llongfile                     // full file name and line number: /a/b/c/d.go:23 
  6.  Lshortfile                    // final file name element and line number: d.go:23. overrides Llongfile 
  7.  LUTC                          // if Ldate or Ltime is set, use UTC rather than the local time zone 
  8.  Lmsgprefix                    // move the "prefix" from the beginning of the line to before the message 
  9.  LstdFlags     = Ldate | Ltime // initial values for the standard logger 

其中 Ldate、Ltime 和 Lmicroseconds 分别表示日期、时间和微秒,需要注意的是,如果设置 Lmicroseconds,那么设置 Ltime,也不会生效。

其中 Llongfile 和 Lshortfile 分别代码绝对路径、源文件名、行号,和代码相对路径、源文件名、行号,需要注意的是,如果设置 Lshortfile,那么即使设置 Llongfile,也不会生效。

其中 LUTC 表示设置时区为 UTC 时区。

其中 LstdFlags 表示标准记录器的初始值,包含日期和时间。

截止到现在,还缺少点东西,就是日志信息的前缀,比如我们需要区分日志信息为 DEBUG、INFO 和 ERROR。是的,我们还有一个函数 SetPrefix 可以实现此功能,源码如下:

  1. func SetPrefix(prefix string) { 
  2.  std.SetPrefix(prefix) 

函数 SetPrefix 接收一个 string 类型的参数,用来设置日志信息的前缀。

03、Logger

log 包定义了一个包含很多方法的类型 Logger。我们通过查看输出功能的函数,发现它们都是调用 std.Output,std 是什么?我们查看 log 包的源码。

  1. type Logger struct { 
  2.  mu     sync.Mutex // ensures atomic writes; protects the following fields 
  3.  prefix string     // prefix on each line to identify the logger (but see Lmsgprefix) 
  4.  flag   int        // properties 
  5.  out    io.Writer  // destination for output 
  6.  buf    []byte     // for accumulating text to write 
  7.  
  8. func New(out io.Writer, prefix string, flag int) *Logger { 
  9.  return &Logger{outout, prefix: prefix, flag: flag} 
  10.  
  11. var std = New(os.Stderr, "", LstdFlags) 

通过阅读源码,我们发现 std 实际上是 Logger 类型的一个实例,Output 是 Logger 的一个方法。

std 通过 New 函数创建,参数分别是 os.Stderr、空字符串和 LstdFlags,分别表示标准错误输出、空字符串前缀和日期时间。

Logger 类型的字段,注释已经说明了,这里就不再赘述了。

自定义 Logger:

  1. func main () { 
  2.  logFile, err := os.OpenFile("error1.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0755) 
  3.  if err != nil { 
  4.   fmt.Println(err) 
  5.   return 
  6.  } 
  7.  defer logFile.Close() 
  8.  logs := DefinesLogger(logFile, "", log.LstdFlags|log.Lshortfile) 
  9.  logs.Debug("message"
  10.  logs.Debugf("%s""content"
  11.  
  12. // 自定义 logger 
  13. type Logger struct { 
  14.  definesLogger *log.Logger 
  15.  
  16. type Level int8 
  17.  
  18. const( 
  19.  LevelDebug Level = iota 
  20.  LevelInfo 
  21.  LevelError 
  22.  
  23. func (l Level) String() string { 
  24.  switch l { 
  25.  case LevelDebug: 
  26.   return " [debug] " 
  27.  case LevelInfo: 
  28.   return " [info] " 
  29.  case LevelError: 
  30.   return " [error] " 
  31.  } 
  32.  return "" 
  33.  
  34. func DefinesLogger(w io.Writer, prefix string, flag int) *Logger { 
  35.  l := log.New(w, prefix, flag) 
  36.  return &Logger{definesLogger: l} 
  37.  
  38. func (l *Logger) Debug(v ...interface{}) { 
  39.  l.definesLogger.Print(LevelDebug, fmt.Sprint(v...)) 
  40.  
  41. func (l *Logger) Debugf(format string, v ...interface{}) { 
  42.  l.definesLogger.Print(LevelDebug, fmt.Sprintf(format, v...)) 
  43.  
  44. func (l *Logger) Info(v ...interface{}) { 
  45.  l.definesLogger.Print(LevelInfo, fmt.Sprint(v...)) 
  46.  
  47. func (l *Logger) Infof(format string, v ...interface{}) { 
  48.  l.definesLogger.Print(LevelInfo, fmt.Sprintf(format, v...)) 
  49.  
  50. func (l *Logger) Error(v ...interface{}) { 
  51.  l.definesLogger.Print(LevelError, fmt.Sprint(v...)) 
  52.  
  53. func (l *Logger) Errorf(format string, v ...interface{}) { 
  54.  l.definesLogger.Print(LevelError, fmt.Sprintf(format, v...)) 

04、总结

本文主要介绍 Golang 语言的标准库中的 log 包,包括 log 包的函数和自定义类型 logger 的使用方法和一些细节上的注意事项。开篇也提到了,log 包不支持日志文件的切割,我们需要自己编码去实现,或者使用三方库,比如 lumberjack。在生产环境中,一般比较少用 log 包来记录日志,通常会使用三方库来记录日志,比如 zap 和 logrus 等。

责任编辑:未丽燕 来源: Golang语言开发栈
相关推荐

2021-09-13 05:02:49

GogRPC语言

2021-06-07 23:19:44

Golang语言 Defer

2021-07-12 05:05:59

Golang语言字段

2021-06-09 23:36:46

Golang语言版本

2021-10-10 23:02:49

Golang语言代码

2021-04-28 09:02:48

Golang语言Context

2021-06-29 23:40:19

Golang语言并发

2021-12-13 01:24:14

语言Golang panic

2023-02-13 00:24:37

Go语言日志库

2022-01-04 23:13:57

语言PanicGolang

2020-10-22 06:59:09

GolangRust语言

2021-11-08 23:09:07

Go排序数据

2023-04-02 23:13:07

Go语言bufio

2021-07-26 11:19:43

微服务开发技术

2023-11-13 21:55:12

Go编程

2021-11-14 23:05:28

GoCast语言

2021-10-31 23:01:50

语言拼接字符串

2009-12-15 17:53:18

Ruby标准库

2021-11-28 23:06:30

语言编程接口

2021-10-26 09:26:21

编程技能开发
点赞
收藏

51CTO技术栈公众号