slog: both AtomicLevel and Level implement Leveler

Introduce the Leveler interface (only method: Level() Level) so that
both AtomicLevel and Level can be used interchangeably.

HandlerOptions.Level is now a Leveler.

The default for HandlerOptions.Level is InfoLevel, meaning
that Debug logs are disabled by default.

This is also now the behavior of the default Handler, which
is used if slog.{Log,Info,Debug,...} are called before
installing a handler. It used to write everything to the
default log.Logger; now it ignores any level below Info.

Change-Id: I0538201cffacd101901179a01f262ae6a5d96797
Reviewed-on: https://go-review.googlesource.com/c/exp/+/431055
Run-TryBot: Jonathan Amsterdam <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>

Author: jba

slog/handler.go

@@ -45,7 +45,9 @@ type defaultHandler struct {
 	attrs []Attr
 }
 
-func (*defaultHandler) Enabled(Level) bool { return true }
+func (*defaultHandler) Enabled(l Level) bool {
+	return l >= InfoLevel
+}
 
 // Collect the level, attributes and message in a string and
 // write it with the default log.Logger.
@@ -75,9 +77,9 @@ type HandlerOptions struct {
 	// "file:line".
 	AddSource bool
 
-	// Ignore records with levels above Level.Level.
-	// If nil, accept all levels.
-	Level *AtomicLevel
+	// Ignore records with levels below Level.Level().
+	// The default is InfoLevel.
+	Level Leveler
 
 	// If set, ReplaceAttr is called on each attribute of the message,
 	// and the returned value is used instead of the original. If the returned
@@ -98,10 +100,14 @@ type commonHandler struct {
 	w                 io.Writer
 }
 
-// Enabled reports whether l is less than or equal to the
-// maximum level.
+// Enabled reports whether l is greater than or equal to the
+// minimum level.
 func (h *commonHandler) Enabled(l Level) bool {
-	return l <= h.opts.Level.Level()
+	minLevel := InfoLevel
+	if h.opts.Level != nil {
+		minLevel = h.opts.Level.Level()
+	}
+	return l >= minLevel
 }
 
 func (h *commonHandler) with(as []Attr) *commonHandler {

slog/handler_test.go

@@ -122,6 +122,32 @@ func upperCaseKey(a Attr) Attr {
 	return a.WithKey(strings.ToUpper(a.Key()))
 }
 
+func TestHandlerEnabled(t *testing.T) {
+	atomicLevel := func(l Level) *AtomicLevel {
+		var al AtomicLevel
+		al.Set(l)
+		return &al
+	}
+
+	for _, test := range []struct {
+		leveler Leveler
+		want    bool
+	}{
+		{nil, true},
+		{WarnLevel, false},
+		{&AtomicLevel{}, true}, // defaults to Info
+		{atomicLevel(WarnLevel), false},
+		{DebugLevel, true},
+		{atomicLevel(DebugLevel), true},
+	} {
+		h := &commonHandler{opts: HandlerOptions{Level: test.leveler}}
+		got := h.Enabled(InfoLevel)
+		if got != test.want {
+			t.Errorf("%v: got %t, want %t", test.leveler, got, test.want)
+		}
+	}
+}
+
 const rfc3339Millis = "2006-01-02T15:04:05.000Z07:00"
 
 func TestAppendTimeRFC3339(t *testing.T) {

slog/level.go

@@ -6,7 +6,6 @@ package slog
 
 import (
 	"fmt"
-	"math"
 	"strconv"
 	"sync/atomic"
 )
@@ -84,30 +83,37 @@ func (l Level) MarshalJSON() ([]byte, error) {
 	return strconv.AppendQuote(nil, l.String()), nil
 }
 
-// An AtomicLevel is Level that can be read and written safely by multiple
+// Level returns the receiver.
+// It implements Leveler.
+func (l Level) Level() Level { return l }
+
+// An AtomicLevel is a Level that can be read and written safely by multiple
 // goroutines.
-// Use NewAtomicLevel to create one.
+// The default value of AtomicLevel is InfoLevel.
 type AtomicLevel struct {
 	val atomic.Int64
 }
 
-// NewAtomicLevel creates an AtomicLevel initialized to the given Level.
-func NewAtomicLevel(l Level) *AtomicLevel {
-	var r AtomicLevel
-	r.Set(l)
-	return &r
+// Level returns r's level.
+func (a *AtomicLevel) Level() Level {
+	return Level(int(a.val.Load()))
 }
 
-// Level returns r's level.
-// If r is nil, it returns the maximum level.
-func (r *AtomicLevel) Level() Level {
-	if r == nil {
-		return Level(math.MaxInt)
-	}
-	return Level(int(r.val.Load()))
+// Set sets the receiver's level to l.
+func (a *AtomicLevel) Set(l Level) {
+	a.val.Store(int64(l))
 }
 
-// Set sets r's level to l.
-func (r *AtomicLevel) Set(l Level) {
-	r.val.Store(int64(l))
+func (a *AtomicLevel) String() string {
+	return fmt.Sprintf("AtomicLevel(%s)", a.Level())
+}
+
+// A Leveler provides a Level value.
+//
+// As Level itself implements Leveler, clients typically supply
+// a Level value wherever a Leveler is needed, such as in HandlerOptions.
+// Clients who need to vary the level dynamically can provide a more complex
+// Leveler implementation such as *AtomicLevel.
+type Leveler interface {
+	Level() Level
 }

slog/level_test.go

@@ -5,7 +5,6 @@
 package slog
 
 import (
-	"math"
 	"testing"
 )
 
@@ -33,16 +32,16 @@ func TestLevelString(t *testing.T) {
 }
 
 func TestAtomicLevel(t *testing.T) {
-	var r *AtomicLevel
-	if got, want := r.Level(), Level(math.MaxInt); got != want {
+	var al AtomicLevel
+	if got, want := al.Level(), InfoLevel; got != want {
 		t.Errorf("got %v, want %v", got, want)
 	}
-	r = NewAtomicLevel(WarnLevel)
-	if got, want := r.Level(), WarnLevel; got != want {
+	al.Set(WarnLevel)
+	if got, want := al.Level(), WarnLevel; got != want {
 		t.Errorf("got %v, want %v", got, want)
 	}
-	r.Set(InfoLevel)
-	if got, want := r.Level(), InfoLevel; got != want {
+	al.Set(InfoLevel)
+	if got, want := al.Level(), InfoLevel; got != want {
 		t.Errorf("got %v, want %v", got, want)
 	}
 

slog/logger_test.go

@@ -25,16 +25,19 @@ func TestLogTextHandler(t *testing.T) {
 
 	check := func(want string) {
 		t.Helper()
-		want = "time=" + timeRE + " " + want
+		if want != "" {
+			want = "time=" + timeRE + " " + want
+		}
 		checkLogOutput(t, buf.String(), want)
 		buf.Reset()
 	}
 
 	l.Info("msg", "a", 1, "b", 2)
 	check(`level=INFO msg=msg a=1 b=2`)
 
+	// By default, debug messages are not printed.
 	l.Debug("bg", Int("a", 1), "b", 2)
-	check(`level=DEBUG msg=bg a=1 b=2`)
+	check("")
 
 	l.Warn("w", Duration("dur", 3*time.Second))
 	check(`level=WARN msg=w dur=3s`)
@@ -58,6 +61,14 @@ func TestConnections(t *testing.T) {
 	Info("msg", "a", 1)
 	checkLogOutput(t, logbuf.String(),
 		`\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2} logger_test.go:\d\d: INFO a=1 msg`)
+	logbuf.Reset()
+	Warn("msg", "b", 2)
+	checkLogOutput(t, logbuf.String(),
+		`\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2} logger_test.go:\d\d: WARN b=2 msg`)
+	// Levels below Info are not printed.
+	logbuf.Reset()
+	Debug("msg", "c", 3)
+	checkLogOutput(t, logbuf.String(), "")
 
 	// Once slog.SetDefault is called, the direction is reversed: the default
 	// log.Logger's output goes through the handler.