Golang 源码剖析:log 标准库

日志

输出

  1. 2018/09/28 20:03:08 EDDYCJY Blog...

构成

[日期]<空格>[时分秒]<空格>[内容]<\n>

源码剖析

Logger

  1. type Logger struct {
  2. mu sync.Mutex
  3. prefix string
  4. flag int
  5. out io.Writer
  6. buf []byte
  7. }
  1. mu:互斥锁,用于确保原子的写入
  2. prefix:每行需写入的日志前缀内容
  3. flag:设置日志辅助信息(时间、文件名、行号)的写入。可选如下标识位:
  1. const (
  2. Ldate = 1 << iota // value: 1
  3. Ltime // value: 2
  4. Lmicroseconds // value: 4
  5. Llongfile // value: 8
  6. Lshortfile // value: 16
  7. LUTC // value: 32
  8. LstdFlags = Ldate | Ltime // value: 3
  9. )
  • Ldate:当地时区的格式化日期:2009/01/23
  • Ltime:当地时区的格式化时间:01:23:23
  • Lmicroseconds:在 Ltime 的基础上,增加微秒的时间数值显示
  • Llongfile:完整的文件名和行号:/a/b/c/d.go:23
  • Lshortfile:当前文件名和行号:d.go:23,会覆盖 Llongfile 标识
  • LUTC:如果设置 Ldate 或 Ltime,且设置 LUTC,则优先使用 UTC 时区而不是本地时区
  • LstdFlags:Logger 的默认初始值(Ldate 和 Ltime)
  1. out:io.Writer
  2. buf:用于存储将要写入的日志内容

New

  1. func New(out io.Writer, prefix string, flag int) *Logger {
  2. return &Logger{out: out, prefix: prefix, flag: flag}
  3. }
  4. var std = New(os.Stderr, "", LstdFlags)

New 方法用于初始化 Logger,接受三个初始参数,可以定制化而在 log 包内默认会初始一个 std,它指向标准输入流。而默认的标准输出、标准错误就是显示器(输出到屏幕上),标准输入就是键盘。辅助的时间信息默认为 Ldate | Ltime,也就是 2009/01/23 01:23:23

  1. // os
  2. var (
  3. Stdin = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
  4. Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
  5. Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
  6. )
  • Stdin:标准输入
  • Stdout:标准输出
  • Stderr:标准错误

Getter

  • Flags
  • Prefix

Setter

  • SetFlags
  • SetPrefix
  • SetOutput

Print, Fatal, Panic*

  1. func Print(v ...interface{}) {
  2. std.Output(2, fmt.Sprint(v...))
  3. }
  4. func Printf(format string, v ...interface{}) {
  5. std.Output(2, fmt.Sprintf(format, v...))
  6. }
  7. func Println(v ...interface{}) {
  8. std.Output(2, fmt.Sprintln(v...))
  9. }
  10. func Fatal(v ...interface{}) {
  11. std.Output(2, fmt.Sprint(v...))
  12. os.Exit(1)
  13. }
  14. func Panic(v ...interface{}) {
  15. s := fmt.Sprint(v...)
  16. std.Output(2, s)
  17. panic(s)
  18. }
  19. ...

这一部分介绍最常用的日志写入方法,从源码可得知 XrintlnXrintf 函数 换行可变参数都是通过 fmt 标准库的方法去实现的

FatalPanic 是通过 os.Exit(1)panic(s) 集成实现的。而具体的组装逻辑是通过 Output 方法实现的

Logger.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
  26. }

Output 方法,简单来讲就是将写入的日志事件信息组装并输出,它会根据 flag 标识位的不同来使用 runtime.Caller 去获取当前 goroutine 所执行的函数文件、行号等调用信息(log 标准库中默认深度为 2)。另外如果结尾不是换行符 \n,将自动补全一个换行

Logger.formatHeader

  1. func (l *Logger) formatHeader(buf *[]byte, t time.Time, file string, line int) {
  2. *buf = append(*buf, l.prefix...)
  3. if l.flag&(Ldate|Ltime|Lmicroseconds) != 0 {
  4. if l.flag&LUTC != 0 {
  5. t = t.UTC()
  6. }
  7. if l.flag&Ldate != 0 {
  8. year, month, day := t.Date()
  9. itoa(buf, year, 4)
  10. *buf = append(*buf, '/')
  11. itoa(buf, int(month), 2)
  12. *buf = append(*buf, '/')
  13. itoa(buf, day, 2)
  14. *buf = append(*buf, ' ')
  15. }
  16. if l.flag&(Ltime|Lmicroseconds) != 0 {
  17. hour, min, sec := t.Clock()
  18. itoa(buf, hour, 2)
  19. *buf = append(*buf, ':')
  20. itoa(buf, min, 2)
  21. *buf = append(*buf, ':')
  22. itoa(buf, sec, 2)
  23. if l.flag&Lmicroseconds != 0 {
  24. *buf = append(*buf, '.')
  25. itoa(buf, t.Nanosecond()/1e3, 6)
  26. }
  27. *buf = append(*buf, ' ')
  28. }
  29. }
  30. if l.flag&(Lshortfile|Llongfile) != 0 {
  31. if l.flag&Lshortfile != 0 {
  32. short := file
  33. for i := len(file) - 1; i > 0; i-- {
  34. if file[i] == '/' {
  35. short = file[i+1:]
  36. break
  37. }
  38. }
  39. file = short
  40. }
  41. *buf = append(*buf, file...)
  42. *buf = append(*buf, ':')
  43. itoa(buf, line, -1)
  44. *buf = append(*buf, ": "...)
  45. }
  46. }

该方法主要是用于格式化日志头(前缀),根据入参不同的标识位,添加分隔符和对应的值到日志信息中。执行流程如下:

(1)如果不是空值,则将 prefix 写入 buf

(2)如果设置 LdateLtimeLmicroseconds,则对应将日期和时间写入 buf

(3)如果设置 LshortfileLlongfile,则对应将文件和行号信息写入 buf

Logger.itoa

  1. func itoa(buf *[]byte, i int, wid int) {
  2. // Assemble decimal in reverse order.
  3. var b [20]byte
  4. bp := len(b) - 1
  5. for i >= 10 || wid > 1 {
  6. wid--
  7. q := i / 10
  8. b[bp] = byte('0' + i - q*10)
  9. bp--
  10. i = q
  11. }
  12. // i < 10
  13. b[bp] = byte('0' + i)
  14. *buf = append(*buf, b[bp:]...)
  15. }

该方法主要用于将整数转换为定长的十进制 ASCII,同时给出负数宽度避免左侧补 0。另外会以相反的顺序组合十进制

如何定制化 Logger

在标准库内,可通过其开放的 New 方法来实现各种各样的自定义 Logger 组件,但是为什么也可以直接 log.Print* 等方法呢?

  1. func New(out io.Writer, prefix string, flag int) *Logger

其实是在标准库内,如果你刚刚细心的看了前面的小节,不难发现其默认实现了一个 Logger 组件

  1. var std = New(os.Stderr, "", LstdFlags)

这也是一个小小的精妙之处 ⭕️

总结

通过查阅 log 标准库的源码,可得知最简单的一个日志包应该如何编写。另外 log 包是在所有涉及到 Logger 的地方都对 sync.Mutex 进行操作(以此解决原子问题),其余逻辑均为组装日志信息和转换数值格式,该包较为经典,可以多读几遍 ?

问题

为什么在调用 runtime.Caller 前要先解锁,后再加锁呢?

ft_authoradmin  ft_create_time2019-06-07 21:40
 ft_update_time2019-06-07 21:40