/
log.go
110 lines (93 loc) 路 2.85 KB
/
log.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
package log
import (
"os"
"time"
"github.com/go-kit/kit/log"
lvl "github.com/go-kit/kit/log/level"
)
// Logger is a interface that can log to different levels.
type Logger interface {
Info(keyvals ...interface{})
Debug(keyvals ...interface{})
Warn(keyvals ...interface{})
Error(keyvals ...interface{})
Fatal(keyvals ...interface{})
// With returns a new Logger that inserts the given key value pairs for each
// statements at each levels
With(keyvals ...interface{}) Logger
}
const (
// LogNone forbids any log entries
LogNone int = iota
// LogInfo sets the logging verbosity to info
LogInfo
// LogDebug sets the logging verbosity to debug
LogDebug
)
// DefaultLevel is the default level where statements are logged. Change the
// value of this variable before init() to change the level of the default
// logger.
var DefaultLevel = LogInfo
// DefaultLogger is the default logger that only statemetns at the
// default level. The level is set by DefaultLevel inside init()..
var DefaultLogger Logger
func init() {
DefaultLogger = NewLogger(DefaultLevel)
}
type kitLogger struct {
log.Logger
}
// NewLogger returns a kit logger that prints statements at the given level.
func NewLogger(level int) Logger {
var opt lvl.Option
switch level {
case LogNone:
opt = lvl.AllowNone()
case LogInfo:
opt = lvl.AllowInfo()
case LogDebug:
opt = lvl.AllowDebug()
default:
panic("unknown log level")
}
return NewKitLogger(opt)
}
// NewKitLoggerFrom returns a Logger out of a go-kit/kit/log logger interface. The
// caller can set the options that it needs to the logger first. By default, it
// wraps the logger with a SyncLogger so concurrent calls are synchronized.
func NewKitLoggerFrom(l log.Logger) Logger {
return &kitLogger{log.NewSyncLogger(l)}
}
// NewKitLogger returns a Logger based on go-kit/kit/log default logger
// structure that outputs to stdout. You can pass in options to only allow
// certain levels. By default, it also includes the caller stack.
func NewKitLogger(opts ...lvl.Option) Logger {
logger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout))
for _, opt := range opts {
logger = lvl.NewFilter(logger, opt)
}
timestamp := log.TimestampFormat(time.Now, time.RFC1123)
logger = log.With(logger, "ts", timestamp)
logger = log.With(logger, "call", log.Caller(8))
return NewKitLoggerFrom(logger)
}
func (k *kitLogger) Info(kv ...interface{}) {
lvl.Info(k.Logger).Log(kv...)
}
func (k *kitLogger) Debug(kv ...interface{}) {
lvl.Debug(k.Logger).Log(kv...)
}
func (k *kitLogger) Warn(kv ...interface{}) {
lvl.Warn(k.Logger).Log(kv...)
}
func (k *kitLogger) Error(kv ...interface{}) {
lvl.Error(k.Logger).Log(kv...)
}
func (k *kitLogger) Fatal(kv ...interface{}) {
lvl.Error(k.Logger).Log(kv...)
os.Exit(1)
}
func (k *kitLogger) With(kv ...interface{}) Logger {
newLogger := log.With(k.Logger, kv...)
return NewKitLoggerFrom(newLogger)
}