mirror of
https://github.com/k3s-io/kubernetes.git
synced 2025-07-23 03:41:45 +00:00
cb6a653777
This replaces the experimental logr v0.4 with the stable v1.1.0
release. This is a breaking API change for some users because:
- Comparing logr.Logger against nil is not possible anymore:
it's now a struct instead of an interface. Code which
allows a nil logger should switch to *logr.Logger as type.
- Logger implementations must be updated in lockstep.
Instead of updating the forked zapr code in json.go, directly using
the original go-logr/zapr is simpler and avoids duplication of effort.
The updated zapr supports logging of numeric verbosity. Error messages
don't have a verbosity (= always get logged), so "v" is not getting
added to them anymore.
Source code logging for panic messages got fixed so that it references
the code with the invalid log call, not the json.go implementation.
Finally, zapr includes additional information in its panic
messages ("zap field", "ignored key", "invalid key").
71 lines
2.0 KiB
Markdown
71 lines
2.0 KiB
Markdown
Zapr :zap:
|
|
==========
|
|
|
|
A [logr](https://github.com/go-logr/logr) implementation using
|
|
[Zap](https://github.com/uber-go/zap).
|
|
|
|
Usage
|
|
-----
|
|
|
|
```go
|
|
import (
|
|
"fmt"
|
|
|
|
"go.uber.org/zap"
|
|
"github.com/go-logr/logr"
|
|
"github.com/go-logr/zapr"
|
|
)
|
|
|
|
func main() {
|
|
var log logr.Logger
|
|
|
|
zapLog, err := zap.NewDevelopment()
|
|
if err != nil {
|
|
panic(fmt.Sprintf("who watches the watchmen (%v)?", err))
|
|
}
|
|
log = zapr.NewLogger(zapLog)
|
|
|
|
log.Info("Logr in action!", "the answer", 42)
|
|
}
|
|
```
|
|
|
|
Increasing Verbosity
|
|
--------------------
|
|
|
|
Zap uses semantically named levels for logging (`DebugLevel`, `InfoLevel`,
|
|
`WarningLevel`, ...). Logr uses arbitrary numeric levels. By default logr's
|
|
`V(0)` is zap's `InfoLevel` and `V(1)` is zap's `DebugLevel` (which is
|
|
numerically -1). Zap does not have named levels that are more verbose than
|
|
`DebugLevel`, but it's possible to fake it.
|
|
|
|
As of zap v1.19.0 you can do something like the following in your setup code:
|
|
|
|
```go
|
|
zc := zap.NewProductionConfig()
|
|
zc.Level = zap.NewAtomicLevelAt(zapcore.Level(-2))
|
|
z, err := zc.Build()
|
|
if err != nil {
|
|
// ...
|
|
}
|
|
log := zapr.NewLogger(z)
|
|
```
|
|
|
|
Zap's levels get more verbose as the number gets smaller and more important and
|
|
the number gets larger (`DebugLevel` is -1, `InfoLevel` is 0, `WarnLevel` is 1,
|
|
and so on).
|
|
|
|
The `-2` in the above snippet means that `log.V(2).Info()` calls will be active.
|
|
`-3` would enable `log.V(3).Info()`, etc. Note that zap's levels are `int8`
|
|
which means the most verbose level you can give it is -128. The zapr
|
|
implementation will cap `V()` levels greater than 127 to 127, so setting the
|
|
zap level to -128 really means "activate all logs".
|
|
|
|
Implementation Details
|
|
----------------------
|
|
|
|
For the most part, concepts in Zap correspond directly with those in logr.
|
|
|
|
Unlike Zap, all fields *must* be in the form of sugared fields --
|
|
it's illegal to pass a strongly-typed Zap field in a key position to any
|
|
of the logging methods (`Log`, `Error`).
|