117 lines
2.9 KiB
Go
117 lines
2.9 KiB
Go
package log
|
|
|
|
import "fmt"
|
|
|
|
// NewFilter wraps next and implements 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 or
|
|
// Error helper methods are squelched.
|
|
func NewFilter(next Logger, options ...Option) Logger {
|
|
l := &filter{
|
|
next: next,
|
|
}
|
|
for _, option := range options {
|
|
option(l)
|
|
}
|
|
return l
|
|
}
|
|
|
|
// NewFilterByLevel wraps next and implements filtering based on a given level.
|
|
// Error is returned if level is not info, error or debug.
|
|
func NewFilterByLevel(next Logger, lvl string) (Logger, error) {
|
|
var option Option
|
|
switch lvl {
|
|
case "info":
|
|
option = AllowInfo()
|
|
case "debug":
|
|
option = AllowDebug()
|
|
case "error":
|
|
option = AllowError()
|
|
default:
|
|
return nil, fmt.Errorf("Expected either \"info\", \"debug\" or \"error\" log level, given %v", lvl)
|
|
}
|
|
return NewFilter(next, option), nil
|
|
}
|
|
|
|
type filter struct {
|
|
next Logger
|
|
allowed level
|
|
errNotAllowed error
|
|
}
|
|
|
|
func (l *filter) Info(msg string, keyvals ...interface{}) error {
|
|
levelAllowed := l.allowed&levelInfo != 0
|
|
if !levelAllowed {
|
|
return l.errNotAllowed
|
|
}
|
|
return l.next.Info(msg, keyvals...)
|
|
}
|
|
|
|
func (l *filter) Debug(msg string, keyvals ...interface{}) error {
|
|
levelAllowed := l.allowed&levelDebug != 0
|
|
if !levelAllowed {
|
|
return l.errNotAllowed
|
|
}
|
|
return l.next.Debug(msg, keyvals...)
|
|
}
|
|
|
|
func (l *filter) Error(msg string, keyvals ...interface{}) error {
|
|
levelAllowed := l.allowed&levelError != 0
|
|
if !levelAllowed {
|
|
return l.errNotAllowed
|
|
}
|
|
return l.next.Error(msg, keyvals...)
|
|
}
|
|
|
|
func (l *filter) With(keyvals ...interface{}) Logger {
|
|
return &filter{next: l.next.With(keyvals...), allowed: l.allowed, errNotAllowed: l.errNotAllowed}
|
|
}
|
|
|
|
// Option sets a parameter for the filter.
|
|
type Option func(*filter)
|
|
|
|
// AllowAll is an alias for AllowDebug.
|
|
func AllowAll() Option {
|
|
return AllowDebug()
|
|
}
|
|
|
|
// AllowDebug allows error, info and debug level log events to pass.
|
|
func AllowDebug() Option {
|
|
return allowed(levelError | levelInfo | levelDebug)
|
|
}
|
|
|
|
// AllowInfo allows error and info level log events to pass.
|
|
func AllowInfo() Option {
|
|
return allowed(levelError | levelInfo)
|
|
}
|
|
|
|
// AllowError allows only error level log events to pass.
|
|
func AllowError() Option {
|
|
return allowed(levelError)
|
|
}
|
|
|
|
// AllowNone allows no leveled log events to pass.
|
|
func AllowNone() Option {
|
|
return allowed(0)
|
|
}
|
|
|
|
func allowed(allowed level) Option {
|
|
return func(l *filter) { l.allowed = allowed }
|
|
}
|
|
|
|
// 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.
|
|
func ErrNotAllowed(err error) Option {
|
|
return func(l *filter) { l.errNotAllowed = err }
|
|
}
|
|
|
|
type level byte
|
|
|
|
const (
|
|
levelDebug level = 1 << iota
|
|
levelInfo
|
|
levelError
|
|
)
|