1 files changed, 28 insertions, 113 deletions
diff --git a/vendor/github.com/go-kit/kit/log/level/level.go b/vendor/github.com/go-kit/kit/log/level/level.go
index dd4ef60..803e8b9 100644
--- a/vendor/github.com/go-kit/kit/log/level/level.go
+++ b/vendor/github.com/go-kit/kit/log/level/level.go
@@ -1,25 +1,28 @@
 package level
 
-import "github.com/go-kit/kit/log"
+import (
+	"github.com/go-kit/log"
+	"github.com/go-kit/log/level"
+)
 
 // Error returns a logger that includes a Key/ErrorValue pair.
 func Error(logger log.Logger) log.Logger {
-	return log.WithPrefix(logger, Key(), ErrorValue())
+	return level.Error(logger)
 }
 
 // Warn returns a logger that includes a Key/WarnValue pair.
 func Warn(logger log.Logger) log.Logger {
-	return log.WithPrefix(logger, Key(), WarnValue())
+	return level.Warn(logger)
 }
 
 // Info returns a logger that includes a Key/InfoValue pair.
 func Info(logger log.Logger) log.Logger {
-	return log.WithPrefix(logger, Key(), InfoValue())
+	return level.Info(logger)
 }
 
 // Debug returns a logger that includes a Key/DebugValue pair.
 func Debug(logger log.Logger) log.Logger {
-	return log.WithPrefix(logger, Key(), DebugValue())
+	return level.Debug(logger)
 }
 
 // NewFilter wraps next and implements level filtering. See the commentary on
@@ -28,76 +31,40 @@ func Debug(logger log.Logger) log.Logger {
 // Info, Warn or Error helper methods are squelched and non-leveled log
 // events are passed to next unmodified.
 func NewFilter(next log.Logger, options ...Option) log.Logger {
-	l := &logger{
-		next: next,
-	}
-	for _, option := range options {
-		option(l)
-	}
-	return l
-}
-
-type logger struct {
-	next           log.Logger
-	allowed        level
-	squelchNoLevel bool
-	errNotAllowed  error
-	errNoLevel     error
-}
-
-func (l *logger) Log(keyvals ...interface{}) error {
-	var hasLevel, levelAllowed bool
-	for i := 1; i < len(keyvals); i += 2 {
-		if v, ok := keyvals[i].(*levelValue); ok {
-			hasLevel = true
-			levelAllowed = l.allowed&v.level != 0
-			break
-		}
-	}
-	if !hasLevel && l.squelchNoLevel {
-		return l.errNoLevel
-	}
-	if hasLevel && !levelAllowed {
-		return l.errNotAllowed
-	}
-	return l.next.Log(keyvals...)
+	return level.NewFilter(next, options...)
 }
 
 // Option sets a parameter for the leveled logger.
-type Option func(*logger)
+type Option = level.Option
 
 // AllowAll is an alias for AllowDebug.
 func AllowAll() Option {
-	return AllowDebug()
+	return level.AllowAll()
 }
 
 // AllowDebug allows error, warn, info and debug level log events to pass.
 func AllowDebug() Option {
-	return allowed(levelError | levelWarn | levelInfo | levelDebug)
+	return level.AllowDebug()
 }
 
 // AllowInfo allows error, warn and info level log events to pass.
 func AllowInfo() Option {
-	return allowed(levelError | levelWarn | levelInfo)
+	return level.AllowInfo()
 }
 
 // AllowWarn allows error and warn level log events to pass.
 func AllowWarn() Option {
-	return allowed(levelError | levelWarn)
+	return level.AllowWarn()
 }
 
 // AllowError allows only error level log events to pass.
 func AllowError() Option {
-	return allowed(levelError)
+	return level.AllowError()
 }
 
 // AllowNone allows no leveled log events to pass.
 func AllowNone() Option {
-	return allowed(0)
-}
-
-func allowed(allowed level) Option {
-	return func(l *logger) { l.allowed = allowed }
+	return level.AllowNone()
 }
 
 // ErrNotAllowed sets the error to return from Log when it squelches a log
@@ -105,7 +72,7 @@ func allowed(allowed level) Option {
 // ErrNotAllowed is nil; in this case the log event is squelched with no
 // error.
 func ErrNotAllowed(err error) Option {
-	return func(l *logger) { l.errNotAllowed = err }
+	return level.ErrNotAllowed(err)
 }
 
 // SquelchNoLevel instructs Log to squelch log events with no level, so that
@@ -113,93 +80,41 @@ func ErrNotAllowed(err error) Option {
 // to true and a log event is squelched in this way, the error value
 // configured with ErrNoLevel is returned to the caller.
 func SquelchNoLevel(squelch bool) Option {
-	return func(l *logger) { l.squelchNoLevel = squelch }
+	return level.SquelchNoLevel(squelch)
 }
 
 // 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.
 func ErrNoLevel(err error) Option {
-	return func(l *logger) { l.errNoLevel = err }
+	return level.ErrNoLevel(err)
 }
 
 // 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.
-func NewInjector(next log.Logger, level Value) log.Logger {
-	return &injector{
-		next:  next,
-		level: level,
-	}
-}
-
-type injector struct {
-	next  log.Logger
-	level interface{}
-}
-
-func (l *injector) Log(keyvals ...interface{}) error {
-	for i := 1; i < len(keyvals); i += 2 {
-		if _, ok := keyvals[i].(*levelValue); ok {
-			return l.next.Log(keyvals...)
-		}
-	}
-	kvs := make([]interface{}, len(keyvals)+2)
-	kvs[0], kvs[1] = key, l.level
-	copy(kvs[2:], keyvals)
-	return l.next.Log(kvs...)
+func NewInjector(next log.Logger, lvl Value) log.Logger {
+	return level.NewInjector(next, lvl)
 }
 
 // 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.
-type Value interface {
-	String() string
-	levelVal()
-}
+type Value = level.Value
 
 // Key returns the unique key added to log events by the loggers in this
 // package.
-func Key() interface{} { return key }
+func Key() interface{} { return level.Key() }
 
 // ErrorValue returns the unique value added to log events by Error.
-func ErrorValue() Value { return errorValue }
+func ErrorValue() Value { return level.ErrorValue() }
 
 // WarnValue returns the unique value added to log events by Warn.
-func WarnValue() Value { return warnValue }
+func WarnValue() Value { return level.WarnValue() }
 
 // InfoValue returns the unique value added to log events by Info.
-func InfoValue() Value { return infoValue }
-
-// DebugValue returns the unique value added to log events by Warn.
-func DebugValue() Value { return debugValue }
-
-var (
-	// key is of type interfae{} so that it allocates once during package
-	// initialization and avoids allocating every time the value is added to a
-	// []interface{} later.
-	key interface{} = "level"
-
-	errorValue = &levelValue{level: levelError, name: "error"}
-	warnValue  = &levelValue{level: levelWarn, name: "warn"}
-	infoValue  = &levelValue{level: levelInfo, name: "info"}
-	debugValue = &levelValue{level: levelDebug, name: "debug"}
-)
-
-type level byte
-
-const (
-	levelDebug level = 1 << iota
-	levelInfo
-	levelWarn
-	levelError
-)
-
-type levelValue struct {
-	name string
-	level
-}
+func InfoValue() Value { return level.InfoValue() }
 
-func (v *levelValue) String() string { return v.name }
-func (v *levelValue) levelVal()      {}
+// DebugValue returns the unique value added to log events by Debug.
+func DebugValue() Value { return level.DebugValue() }