README
¶
klog wrapper of zap
inspired by istio/klog.
usage
import
import this package by github.com/xial-thu/klog
initialization
for example, in main.go
// Unchanged
klog.InitFlags(nil)
flag.StringVar(&kubeconfig, "kubeconfig", "", "path to Kubernetes config file")
flag.Parse()
// Append a new API
klog.Singleton()
If Singleton() is not called, the default global no-ops logger will work, which means you are not able to see any real log.
Due to some gaps between klog and zap, parameters shall be converted, and the conversion must be done after flag.Parse(). klog.Singleton() inits an unique global logger whose configuration is slightly different from default zap production configuration at:
Timekeyis set to "time"EncodeTimeis set toISO8601TimeEncoder
flags
Not all flags defined in klog is supported, or rather say, not all the flags still make sense. Only alsologtostderr and v is supported currently.
v: still supportsklog.V(2).Info()syntax. But the level ofklog.Info()is INFO; thatklog.V(3).Info()is DEBUG. If v is set to zero, zap DEBUG log will be ignored. Default to 0alsologtostderr: default to true. If set to false, INFO and DEBUG log will only output to stdout
structured logging
There're 3 APIs:
With(): parse each field and value from input.WithFields(struct{A string}{"hi"})will output"A":"hi". If you care the fields in your struct and hope to extract them, useWith()WithAll(): sugar ofzap.Any(). e.g.WithFields(struct{A string}{"hi"})will output"":{"A":"hi"}. If you want to record the name of your struct, useWithAll()WithFields(): e.g.WithFields("ID", 1, "name": "hi"), just another sugar ofsugar.With()
Tips of With():
- Only struct or map will be accepted
- If arg is a struct, only exported field(which means "FieldName", not "fieldname") will be logged
- If arg is a map, only accept maps whose key is string
- If you have nested structs or maps, consider spliting them into several anomony parts
- If you don't want some fields to be logged automatically, unexport them
Some examples of With():
type S struct {
A int
B string
}
type Q struct {
D ID
}
s := S{
A: 10,
B: "abc",
}
q := Q{
D: ID(1),
}
c := ""
// struct args
With(s).Info(c) // "A":10,"B":"abc"
With(s, q).Info(c) // "A":10,"B":"abc","D":1
// anomony
With(struct {
A int
B int
}{1, 2}).Info(c) // "A":1,"B":2
// map args
With(map[string]int{"A":1}).Info(c) // "A":1
performance of With()
| case | ns/op | B/op | allocs/op |
|---|---|---|---|
| With every time | 3121 | 2884 | 20 |
| WithField every time | 2239 | 1568 | 9 |
| WithAll | 3215 | 2642 | 14 |
| With once | 573 | 7 | 1 |
Due to reflect, With() is slow. It indicates us that it's better to write like this instead of parsing interfaces every time.
newLogger := klog.With(something)
newLogger.Info(something)
limitation
- default field is empty.
- structured logging still needs modification in business logic.
- support of flags needs more work.
Documentation
¶
Index ¶
- func Error(args ...interface{})
- func ErrorDepth(depth int, args ...interface{})
- func Errorf(format string, args ...interface{})
- func Errorln(args ...interface{})
- func Exit(args ...interface{})
- func ExitDepth(depth int, args ...interface{})
- func Exitf(format string, args ...interface{})
- func Exitln(args ...interface{})
- func Fatal(args ...interface{})
- func FatalDepth(depth int, args ...interface{})
- func Fatalf(format string, args ...interface{})
- func Fatalln(args ...interface{})
- func Flush()
- func Info(args ...interface{})
- func InfoDepth(depth int, args ...interface{})
- func Infof(format string, args ...interface{})
- func Infoln(args ...interface{})
- func InitFlags(flagset *pflag.FlagSet)
- func SetLevel(v Level)
- func Warning(args ...interface{})
- func WarningDepth(depth int, args ...interface{})
- func Warningf(format string, args ...interface{})
- func Warningln(args ...interface{})
- type Config
- type Klogger
- func (k *Klogger) Error(args ...interface{})
- func (k *Klogger) ErrorDepth(depth int, args ...interface{})
- func (k *Klogger) Errorf(format string, args ...interface{})
- func (k *Klogger) Errorln(args ...interface{})
- func (k *Klogger) Exit(args ...interface{})
- func (k *Klogger) ExitDepth(depth int, args ...interface{})
- func (k *Klogger) Exitf(format string, args ...interface{})
- func (k *Klogger) Exitln(args ...interface{})
- func (k *Klogger) Fatal(args ...interface{})
- func (k *Klogger) FatalDepth(depth int, args ...interface{})
- func (k *Klogger) Fatalf(format string, args ...interface{})
- func (k *Klogger) Fatalln(args ...interface{})
- func (k *Klogger) Info(args ...interface{})
- func (k *Klogger) InfoDepth(depth int, args ...interface{})
- func (k *Klogger) Infof(format string, args ...interface{})
- func (k *Klogger) Infoln(args ...interface{})
- func (k *Klogger) SetLevel(v Level)
- func (k *Klogger) V(level Level) Verbose
- func (k *Klogger) Warning(args ...interface{})
- func (k *Klogger) WarningDepth(depth int, args ...interface{})
- func (k *Klogger) Warningf(format string, args ...interface{})
- func (k *Klogger) Warningln(args ...interface{})
- func (k *Klogger) With(args ...interface{}) *Klogger
- func (k *Klogger) WithAll(args ...interface{}) *Klogger
- func (k *Klogger) WithFields(args ...interface{}) *Klogger
- type Level
- type Verbose
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
Types ¶
type Config ¶
type Config struct {
// contains filtered or unexported fields
}
Config is the mixture of zap config and klog config
type Klogger ¶
type Klogger struct {
// contains filtered or unexported fields
}
Klogger wraps a sugarlogger
func With ¶
func With(args ...interface{}) *Klogger
With fills k-v of a struct into a logger, however it's relatively slow
func WithAll ¶
func WithAll(args ...interface{}) *Klogger
WithAll fills each arg directly without parsing fields and values Only valid for exported fields
func WithFields ¶
func WithFields(args ...interface{}) *Klogger
WithFields requires user to fill in k-v pairs
func (*Klogger) ErrorDepth ¶
ErrorDepth is a shim
func (*Klogger) FatalDepth ¶
FatalDepth is a shim
func (*Klogger) WarningDepth ¶
WarningDepth is a shim
func (*Klogger) With ¶
With fills k-v of a struct into a logger, however it's relatively slow Only struct and map will be accepted:
- struct: only exported field will be added
- map: only accept string type as key
func (*Klogger) WithAll ¶
WithAll fills each arg directly without parsing fields and values Only valid for exported fields
func (*Klogger) WithFields ¶
WithFields requires user to fill in k-v pairs
Source Files