Collapse Level and Logger into one

Signed-off-by: Chris Koch <[email protected]>

llog/default_test.go

@@ -5,32 +5,16 @@
 package llog_test
 
 import (
-	"log"
 	"log/slog"
-	"os"
 
 	"github.com/u-root/uio/llog"
 )
 
-func ExampleDefault() {
-	// Example is reproducible without date/time displayed.
-	log.SetFlags(0)
-	// Examples only go out to stdout.
-	log.SetOutput(os.Stdout)
-
+func ExampleDefault_withtime() {
 	l := llog.Default()
 	l.Infof("An INFO level string")
 	l.Debugf("A DEBUG level that does not appear")
 
-	l.Level = llog.Level(slog.LevelDebug)
+	l.Level = slog.LevelDebug
 	l.Debugf("A DEBUG level that appears")
-
-	l.Warnf("I'm warning you")
-	l.Errorf("This is going to error")
-
-	// Output:
-	// INFO An INFO level string
-	// DEBUG A DEBUG level that appears
-	// WARN I'm warning you
-	// ERROR This is going to error
 }

llog/example_test.go

@@ -18,7 +18,7 @@ func someFunc(v llog.Printf) {
 func Example() {
 	l := llog.Default()
 	// If -v is set, l.Level becomes slog.LevelDebug.
-	l.Level.RegisterDebugFlag(flag.CommandLine, "v")
+	l.RegisterDebugFlag(flag.CommandLine, "v")
 	flag.Parse()
 
 	someFunc(l.Debugf)

llog/levellog.go

@@ -15,33 +15,6 @@ import (
 	"testing"
 )
 
-// Level can be used to create flags (not atomic safe).
-type Level slog.Level
-
-// RegisterLevelFlag registers a flag that sets the given numeric level to l.
-func (l *Level) RegisterLevelFlag(f *flag.FlagSet, flagName string) {
-	f.IntVar((*int)(l), flagName, int(*l), "Level to log at. Lower level emits more logs. -4 = DEBUG, 0 = INFO, 4 = WARN, 8 = ERROR")
-}
-
-// RegisterVerboseFlag registers a boolean flag that, if set, assigns verboseLevel as the level.
-func (l *Level) RegisterVerboseFlag(f *flag.FlagSet, flagName string, verboseLevel slog.Level) {
-	f.BoolFunc(flagName, fmt.Sprintf("If set, logs at %d level", verboseLevel), func(val string) error {
-		b, err := strconv.ParseBool(val)
-		if err != nil {
-			return err
-		}
-		if b {
-			*l = Level(verboseLevel)
-		}
-		return nil
-	})
-}
-
-// RegisterDebugFlag registers a boolean flag that, if set, assigns LevelDebug as the level.
-func (l *Level) RegisterDebugFlag(f *flag.FlagSet, flagName string) {
-	l.RegisterVerboseFlag(f, flagName, slog.LevelDebug)
-}
-
 // Default is the stdlib default log sink.
 func Default() *Logger {
 	return &Logger{Sink: SinkFor(log.Printf)}
@@ -50,12 +23,12 @@ func Default() *Logger {
 // Test is a logger that prints every level to t.Logf.
 func Test(tb testing.TB) *Logger {
 	tb.Helper()
-	return &Logger{Sink: SinkFor(tb.Logf), Level: Level(math.MinInt32)}
+	return &Logger{Sink: SinkFor(tb.Logf), Level: math.MinInt32}
 }
 
 // Debug prints to log.Printf at the debug level.
 func Debug() *Logger {
-	return &Logger{Sink: SinkFor(log.Printf), Level: Level(slog.LevelDebug)}
+	return &Logger{Sink: SinkFor(log.Printf), Level: slog.LevelDebug}
 }
 
 // Printf is a logger printf function.
@@ -81,20 +54,44 @@ func SinkFor(p Printf) Sink {
 // Logger and Sink may be nil in order to log nothing.
 type Logger struct {
 	Sink  Sink
-	Level Level
+	Level slog.Level
 }
 
 // New creates a logger from p which prepends the log level to the output and
 // uses l as the default log level.
 //
 // Logs with level >= l will be printed using p.
-func New(l Level, p Printf) *Logger {
+func New(l slog.Level, p Printf) *Logger {
 	return &Logger{
 		Sink:  SinkFor(p),
 		Level: l,
 	}
 }
 
+// RegisterLevelFlag registers a flag that sets the given numeric level as the level.
+func (l *Logger) RegisterLevelFlag(f *flag.FlagSet, flagName string) {
+	f.IntVar((*int)(&l.Level), flagName, int(l.Level), "Level to log at. Lower level emits more logs. -4 = DEBUG, 0 = INFO, 4 = WARN, 8 = ERROR")
+}
+
+// RegisterVerboseFlag registers a boolean flag that, if set, assigns verboseLevel as the level.
+func (l *Logger) RegisterVerboseFlag(f *flag.FlagSet, flagName string, verboseLevel slog.Level) {
+	f.BoolFunc(flagName, fmt.Sprintf("If set, logs at %d level", verboseLevel), func(val string) error {
+		b, err := strconv.ParseBool(val)
+		if err != nil {
+			return err
+		}
+		if b {
+			l.Level = verboseLevel
+		}
+		return nil
+	})
+}
+
+// RegisterDebugFlag registers a boolean flag that, if set, assigns LevelDebug as the level.
+func (l *Logger) RegisterDebugFlag(f *flag.FlagSet, flagName string) {
+	l.RegisterVerboseFlag(f, flagName, slog.LevelDebug)
+}
+
 // Printf returns a Printf that can be passed around to log at the given level.
 func (l *Logger) Printf(level slog.Level) Printf {
 	if l == nil || l.Sink == nil {
@@ -142,7 +139,7 @@ func (l *Logger) Logf(level slog.Level, fmt string, args ...any) {
 	if l == nil || l.Sink == nil {
 		return
 	}
-	if Level(level) >= l.Level {
+	if level >= l.Level {
 		l.Sink(level, fmt, args...)
 	}
 }

llog/llog_test.go

@@ -17,104 +17,104 @@ import (
 func TestLevelFlag(t *testing.T) {
 	for _, tt := range []struct {
 		args []string
-		want Level
+		want slog.Level
 	}{
 		{
 			args: []string{"-level=4"},
-			want: Level(slog.LevelWarn),
+			want: slog.LevelWarn,
 		},
 		{
 			args: []string{},
-			want: Level(slog.LevelInfo),
+			want: slog.LevelInfo,
 		},
 	} {
 		f := flag.NewFlagSet("", flag.ContinueOnError)
 
-		var v Level
+		v := &Logger{}
 		v.RegisterLevelFlag(f, "level")
 		_ = f.Parse(tt.args)
 
-		if v != tt.want {
+		if v.Level != tt.want {
 			t.Errorf("Parse(%#v) = %v, want %v", tt.args, v, tt.want)
 		}
 	}
 
 	for _, tt := range []struct {
 		args []string
-		want Level
+		want slog.Level
 		err  error
 	}{
 		{
 			args: []string{"-v"},
-			want: Level(slog.LevelWarn),
+			want: slog.LevelWarn,
 		},
 		{
 			args: []string{},
-			want: Level(slog.LevelInfo),
+			want: slog.LevelInfo,
 		},
 		{
 			args: []string{"-v=true"},
-			want: Level(slog.LevelWarn),
+			want: slog.LevelWarn,
 		},
 		{
 			args: []string{"-v=true", "-v=false"},
-			want: Level(slog.LevelWarn),
+			want: slog.LevelWarn,
 		},
 		{
 			args: []string{"-v=foobar"},
-			want: Level(slog.LevelInfo),
+			want: slog.LevelInfo,
 			err:  strconv.ErrSyntax,
 		},
 	} {
 		f := flag.NewFlagSet("", flag.ContinueOnError)
 
-		var v Level
+		v := &Logger{}
 		v.RegisterVerboseFlag(f, "v", slog.LevelWarn)
 		// Parse doesn't use %w.
 		if err := f.Parse(tt.args); err != tt.err && err != nil && !strings.Contains(err.Error(), tt.err.Error()) {
 			t.Errorf("Parse(%#v) = %v, want %v", tt.args, err, tt.err)
 		}
-		if v != tt.want {
+		if v.Level != tt.want {
 			t.Errorf("Parse(%#v) = %v, want %v", tt.args, v, tt.want)
 		}
 	}
 
 	for _, tt := range []struct {
 		args []string
-		want Level
+		want slog.Level
 		err  error
 	}{
 		{
 			args: []string{"-v"},
-			want: Level(slog.LevelDebug),
+			want: slog.LevelDebug,
 		},
 		{
 			args: []string{},
-			want: Level(slog.LevelInfo),
+			want: slog.LevelInfo,
 		},
 		{
 			args: []string{"-v=true"},
-			want: Level(slog.LevelDebug),
+			want: slog.LevelDebug,
 		},
 		{
 			args: []string{"-v=true", "-v=false"},
-			want: Level(slog.LevelDebug),
+			want: slog.LevelDebug,
 		},
 		{
 			args: []string{"-v=foobar"},
-			want: Level(slog.LevelInfo),
+			want: slog.LevelInfo,
 			err:  strconv.ErrSyntax,
 		},
 	} {
 		f := flag.NewFlagSet("", flag.ContinueOnError)
 
-		var v Level
+		v := &Logger{}
 		v.RegisterDebugFlag(f, "v")
 		// Parse doesn't use %w.
 		if err := f.Parse(tt.args); err != tt.err && err != nil && !strings.Contains(err.Error(), tt.err.Error()) {
 			t.Errorf("Parse(%#v) = %v, want %v", tt.args, err, tt.err)
 		}
-		if v != tt.want {
+		if v.Level != tt.want {
 			t.Errorf("Parse(%#v) = %v, want %v", tt.args, v, tt.want)
 		}
 	}
@@ -134,7 +134,7 @@ func TestNilLogger(t *testing.T) {
 
 func TestLog(t *testing.T) {
 	var s strings.Builder
-	l := New(Level(slog.LevelDebug), func(format string, args ...any) {
+	l := New(slog.LevelDebug, func(format string, args ...any) {
 		fmt.Fprintf(&s, format+"\n", args...)
 	})
 
@@ -169,6 +169,14 @@ func TestDefaults(t *testing.T) {
 		t.Errorf("got %v, want %v", got, want)
 	}
 
+	l = Default()
+	l.Debugf("bazzed")
+	l.Infof("stuff")
+	want = "DEBUG foobar\nINFO stuff\n"
+	if got := s.String(); got != want {
+		t.Errorf("got %v, want %v", got, want)
+	}
+
 	l = Test(t)
 	l.Debugf("more foobar")
 }