package level
Import Path
github.com/go-kit/log/level (on go.dev)
Dependency Relation
imports 3 packages, and imported by 8 packages
Involved Source Files
Package level implements leveled logging on top of Go kit's log package. To
use the level package, create a logger as per normal in your func main, and
wrap it with level.NewFilter.
var logger log.Logger
logger = log.NewLogfmtLogger(os.Stderr)
logger = level.NewFilter(logger, level.AllowInfo()) // <--
logger = log.With(logger, "ts", log.DefaultTimestampUTC)
It's also possible to configure log level from a string. For instance from
a flag, environment variable or configuration file.
fs := flag.NewFlagSet("myprogram")
lvl := fs.String("log", "info", "debug, info, warn, error")
var logger log.Logger
logger = log.NewLogfmtLogger(os.Stderr)
logger = level.NewFilter(logger, level.Allow(level.ParseDefault(*lvl, level.InfoValue()))) // <--
logger = log.With(logger, "ts", log.DefaultTimestampUTC)
Then, at the callsites, use one of the level.Debug, Info, Warn, or Error
helper methods to emit leveled log events.
logger.Log("foo", "bar") // as normal, no level
level.Debug(logger).Log("request_id", reqID, "trace_data", trace.Get())
if value > 100 {
level.Error(logger).Log("value", value)
}
NewFilter allows precise control over what happens when a log event is
emitted without a level key, or if a squelched level is used. Check the
Option functions for details.
level.go
Code Examples
package main
import (
"os"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
)
func main() {
logger := log.NewLogfmtLogger(os.Stdout)
level.Debug(logger).Log("msg", "this message is at the debug level")
level.Info(logger).Log("msg", "this message is at the info level")
level.Warn(logger).Log("msg", "this message is at the warn level")
level.Error(logger).Log("msg", "this message is at the error level")
}
package main
import (
"errors"
"os"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
)
func main() {
// Set up logger with level filter.
logger := log.NewLogfmtLogger(os.Stdout)
logger = level.NewFilter(logger, level.AllowInfo())
logger = log.With(logger, "caller", log.DefaultCaller)
// Use level helpers to log at different levels.
level.Error(logger).Log("err", errors.New("bad data"))
level.Info(logger).Log("event", "data saved")
level.Debug(logger).Log("next item", 17) // filtered
}
package main
import (
"errors"
"flag"
"os"
"github.com/go-kit/log"
"github.com/go-kit/log/level"
)
func main() {
fs := flag.NewFlagSet("example", flag.ExitOnError)
lvl := fs.String("log-level", "", `"debug", "info", "warn" or "error"`)
fs.Parse([]string{"-log-level", "info"})
// Set up logger with level filter.
logger := log.NewLogfmtLogger(os.Stdout)
logger = level.NewFilter(logger, level.Allow(level.ParseDefault(*lvl, level.DebugValue())))
logger = log.With(logger, "caller", log.DefaultCaller)
// Use level helpers to log at different levels.
level.Error(logger).Log("err", errors.New("bad data"))
level.Info(logger).Log("event", "data saved")
level.Debug(logger).Log("next item", 17) // filtered
}
Package-Level Type Names (total 2)
Option sets a parameter for the leveled logger.
func Allow(v Value) Option
func AllowAll() Option
func AllowDebug() Option
func AllowError() Option
func AllowInfo() Option
func AllowNone() Option
func AllowWarn() Option
func ErrNoLevel(err error) Option
func ErrNotAllowed(err error) Option
func SquelchNoLevel(squelch bool) Option
func NewFilter(next log.Logger, options ...Option) log.Logger
Value is the interface that each of the canonical level values implement.
It contains unexported methods that prevent types from other packages from
implementing it and guaranteeing that NewFilter can distinguish the levels
defined in this package from all other values.
( Value) String() string
Value : expvar.Var
Value : fmt.Stringer
func DebugValue() Value
func ErrorValue() Value
func InfoValue() Value
func Parse(level string) (Value, error)
func ParseDefault(level string, def Value) Value
func WarnValue() Value
func Allow(v Value) Option
func NewInjector(next log.Logger, level Value) log.Logger
func ParseDefault(level string, def Value) Value
Package-Level Functions (total 23)
Allow the provided log level to pass.
AllowAll is an alias for AllowDebug.
AllowDebug allows error, warn, info and debug level log events to pass.
AllowError allows only error level log events to pass.
AllowInfo allows error, warn and info level log events to pass.
AllowNone allows no leveled log events to pass.
AllowWarn allows error and warn level log events to pass.
Debug returns a logger that includes a Key/DebugValue pair.
DebugValue returns the unique value added to log events by Debug.
ErrNoLevel sets the error to return from Log when it squelches a log event
with no level. By default, ErrNoLevel is nil; in this case the log event is
squelched with no error.
ErrNotAllowed sets the error to return from Log when it squelches a log
event disallowed by the configured Allow[Level] option. By default,
ErrNotAllowed is nil; in this case the log event is squelched with no
error.
Error returns a logger that includes a Key/ErrorValue pair.
ErrorValue returns the unique value added to log events by Error.
Info returns a logger that includes a Key/InfoValue pair.
InfoValue returns the unique value added to log events by Info.
Key returns the unique key added to log events by the loggers in this
package.
NewFilter wraps next and implements level filtering. See the commentary on
the Option functions for a detailed description of how to configure levels.
If no options are provided, all leveled log events created with Debug,
Info, Warn or Error helper methods are squelched and non-leveled log
events are passed to next unmodified.
NewInjector wraps next and returns a logger that adds a Key/level pair to
the beginning of log events that don't already contain a level. In effect,
this gives a default level to logs without a level.
Parse a string to its corresponding level value. Valid strings are "debug",
"info", "warn", and "error". Strings are normalized via strings.TrimSpace and
strings.ToLower.
ParseDefault calls Parse and returns the default Value on error.
SquelchNoLevel instructs Log to squelch log events with no level, so that
they don't proceed through to the wrapped logger. If SquelchNoLevel is set
to true and a log event is squelched in this way, the error value
configured with ErrNoLevel is returned to the caller.
Warn returns a logger that includes a Key/WarnValue pair.
WarnValue returns the unique value added to log events by Warn.
Package-Level Variables (only one)
ErrInvalidLevelString is returned whenever an invalid string is passed to Parse.
 |
The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |