8.2 log

跟煎鱼学 Go
Search…
跟煎鱼学 Go
Introduction
8.2 log
日志
输出
1
2018/09/28 20:03:08 EDDYCJY Blog...
Copied!
构成
[日期]<空格>[时分秒]<空格>[内容]<\n>
源码剖析
Logger
1
type Logger struct {
2
    mu     sync.Mutex 
3
    prefix string
4
    flag   int
5
    out    io.Writer
6
    buf    []byte
7
}
Copied!
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
)
Copied!
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）
out：io.Writer
buf：用于存储将要写入的日志内容
New
1
func New(out io.Writer, prefix string, flag int) *Logger {
2
    return &Logger{out: out, prefix: prefix, flag: flag}
3
}
4
​
5
var std = New(os.Stderr, "", LstdFlags)
Copied!
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
)
Copied!
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
​
5
func Printf(format string, v ...interface{}) {
6
    std.Output(2, fmt.Sprintf(format, v...))
7
}
8
​
9
func Println(v ...interface{}) {
10
    std.Output(2, fmt.Sprintln(v...))
11
}
12
​
13
func Fatal(v ...interface{}) {
14
    std.Output(2, fmt.Sprint(v...))
15
    os.Exit(1)
16
}
17
​
18
func Panic(v ...interface{}) {
19
    s := fmt.Sprint(v...)
20
    std.Output(2, s)
21
    panic(s)
22
}
23
​
24
...
Copied!
这一部分介绍最常用的日志写入方法，从源码可得知 Xrintln、Xrintf 函数 换行、可变参数都是通过 fmt 标准库的方法去实现的
Fatal 和 Panic 是通过 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
}
Copied!
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
}
Copied!
该方法主要是用于格式化日志头（前缀），根据入参不同的标识位，添加分隔符和对应的值到日志信息中。执行流程如下：
（1）如果不是空值，则将 prefix 写入 buf
（2）如果设置 Ldate、Ltime、Lmicroseconds，则对应将日期和时间写入 buf
（3）如果设置 Lshortfile、Llongfile，则对应将文件和行号信息写入 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
}
Copied!
该方法主要用于将整数转换为定长的十进制 ASCII，同时给出负数宽度避免左侧补 0。另外会以相反的顺序组合十进制
如何定制化 Logger
在标准库内，可通过其开放的 New 方法来实现各种各样的自定义 Logger 组件，但是为什么也可以直接 log.Print* 等方法呢？
1
func New(out io.Writer, prefix string, flag int) *Logger
Copied!
其实是在标准库内，如果你刚刚细心的看了前面的小节，不难发现其默认实现了一个 Logger 组件
1
var std = New(os.Stderr, "", LstdFlags)
Copied!
这也是一个小小的精妙之处 ⭕️
总结
通过查阅 log 标准库的源码，可得知最简单的一个日志包应该如何编写。另外 log 包是在所有涉及到 Logger 的地方都对 sync.Mutex 进行操作（以此解决原子问题），其余逻辑均为组装日志信息和转换数值格式，该包较为经典，可以多读几遍 😄
问题
为什么在调用 runtime.Caller 前要先解锁，后再加锁呢?
8.1 fmt
8.3 unsafe
Last modified 2yr ago
Copy link
Contents