filter

log/filter.go

@@ -0,0 +1,97 @@
+package log
+
+// 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
+}
+
+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 l.next.With(keyvals...)
+}
+
+// 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, warn, info and debug level log events to pass.
+func AllowDebug() Option {
+	return allowed(levelError | levelInfo | levelDebug)
+}
+
+// AllowInfo allows error, warn 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
+)