Drop fields in entries with level < log's level

This is a big saver when doing debug logging in tight loop, but needs to be clearly documented.

```bash
name                                         old alloc/op   new alloc/op   delta
Logger_levels/level_not_met-10                   264B ± 0%      264B ± 0%     ~     (all equal)
Logger_levels/level_not_met,_one_field-10        344B ± 0%      264B ± 0%  -23.26%  (p=0.029 n=4+4)
Logger_levels/level_not_met,_many_fields-10    6.17kB ± 0%    0.52kB ± 0%  -91.57%  (p=0.029 n=4+4)
Logger_levels/level_met-10                     18.5kB ± 0%    18.5kB ± 0%     ~     (all equal)
Logger_levels/level_met,_one_field-10          2.02kB ± 0%    2.02kB ± 0%     ~     (all equal)
Logger_levels/level_met,_many_fields-10        7.84kB ± 0%    7.84kB ± 0%     ~     (all equal)

name                                         old allocs/op  new allocs/op  delta
Logger_levels/level_not_met-10                   13.0 ± 0%      13.0 ± 0%     ~     (all equal)
Logger_levels/level_not_met,_one_field-10        15.0 ± 0%      13.0 ± 0%  -13.33%  (p=0.029 n=4+4)
Logger_levels/level_not_met,_many_fields-10      85.0 ± 0%      45.0 ± 0%  -47.06%  (p=0.029 n=4+4)
Logger_levels/level_met-10                        512 ± 0%       512 ± 0%     ~     (all equal)
Logger_levels/level_met,_one_field-10            55.0 ± 0%      55.0 ± 0%     ~     (all equal)
Logger_levels/level_met,_many_fields-10           125 ± 0%       125 ± 0%     ~     (all equal)
```

Author: bep

README.md

@@ -10,4 +10,42 @@ Main changes:
 * Trim unneeded dependencies.
 * Make `Fields` into a slice to preserve log order.
 * Split `Entry` into `Entry` and `EntryFields`. This is easier to reason about and more effective.
-* Rework the logger interface to allow lazy creation of messages, e.g. `Info(fmt.Stringer)`.
+* Split the old `Interface` in two and remove all but one `Log` method (see below).
+* This allows for lazy creation of messages in `Log(fmt.Stringer)` and ignoring fields added in `LevelLogger`s with levels below the `Logger`'s.
+
+
+```go
+// Logger is the main interface for the logger.
+type Logger interface {
+	// WithLevel returns a new entry with `level` set.
+	WithLevel(Level) *EntryFields
+}
+
+// LevelLogger handles logging for a given level.
+type LevelLogger interface {
+	// Log logs a message at the given level using the string from calling s.String().
+	// Note that s.String() will not be called if the level is not enabled.
+	Log(s fmt.Stringer)
+
+	// WithLevel returns a new entry with `level` set.
+	WithLevel(Level) *EntryFields
+
+	// WithFields returns a new entry with the`fields` in fields set.
+	// This is a noop if LevelLogger's level is less than Logger's.
+	WithFields(fields Fielder) *EntryFields
+
+	// WithLevel returns a new entry with the field f set with value v
+	// This is a noop if LevelLogger's level is less than Logger's.
+	WithField(f string, v any) *EntryFields
+
+	// WithDuration returns a new entry with the "duration" field set
+	// to the given duration in milliseconds.
+	// This is a noop if LevelLogger's level is less than Logger's.
+	WithDuration(time.Duration) *EntryFields
+
+	// WithError returns a new entry with the "error" set to `err`.
+	// This is a noop if err is nil or  LevelLogger's level is less than Logger's.
+	WithError(error) *EntryFields
+}
+
+```

default.go

@@ -9,8 +9,8 @@ import (
 
 // assert interface compliance.
 var (
-	_ Logger = (*EntryFields)(nil)
-	_ Logger = (*Entry)(nil)
+	_ LevelLogger = (*EntryFields)(nil)
+	_ LevelLogger = (*Entry)(nil)
 )
 
 // EntryFields represents a single log entry at a given log level.
@@ -57,26 +57,30 @@ func NewEntry(log *logger) *EntryFields {
 	}
 }
 
-// WithLevel returns a new entry with `level` set.
 func (e EntryFields) WithLevel(level Level) *EntryFields {
 	e.Level = level
 	return &e
 }
 
-// WithFields returns a new entry with `fields` set.
 func (e EntryFields) WithFields(fielder Fielder) *EntryFields {
+	if e.isLevelDisabled() {
+		return &e
+	}
 	e.Fields = append(e.Fields, fielder.Fields()...)
 	return &e
 }
 
-// WithField returns a new entry with the `key` and `value` set.
 func (e *EntryFields) WithField(key string, value any) *EntryFields {
+	if e.isLevelDisabled() {
+		return e
+	}
 	return e.WithFields(Fields{{key, value}})
 }
 
-// WithDuration returns a new entry with the "duration" field set
-// to the given duration in milliseconds.
 func (e *EntryFields) WithDuration(d time.Duration) *EntryFields {
+	if e.isLevelDisabled() {
+		return e
+	}
 	return e.WithField("duration", d.Milliseconds())
 }
 
@@ -85,7 +89,7 @@ func (e *EntryFields) WithDuration(d time.Duration) *EntryFields {
 // The given error may implement .Fielder, if it does the method
 // will add all its `.Fields()` into the returned entry.
 func (e *EntryFields) WithError(err error) *EntryFields {
-	if err == nil {
+	if err == nil || e.isLevelDisabled() {
 		return e
 	}
 
@@ -113,6 +117,10 @@ func (e *EntryFields) WithError(err error) *EntryFields {
 	return ctx
 }
 
+func (e *EntryFields) isLevelDisabled() bool {
+	return e.Level < e.Logger.Level
+}
+
 // Log a message at the given level.
 func (e *EntryFields) Log(s fmt.Stringer) {
 	e.Logger.log(e, s)

entry.go

@@ -27,21 +27,21 @@ func TestEntry_WithFields(t *testing.T) {
 }
 
 func TestEntry_WithField(t *testing.T) {
-	a := NewEntry(nil)
+	a := NewLogger(LoggerConfig{Handler: NoopHandler, Level: InfoLevel}).WithLevel(InfoLevel)
 	b := a.WithField("foo", "baz").WithField("foo", "bar")
 	qt.Assert(t, a.distinctFieldsLastByName(), qt.IsNil)
 	qt.Assert(t, b.distinctFieldsLastByName(), qt.DeepEquals, Fields{{"foo", "bar"}})
 }
 
 func TestEntry_WithError(t *testing.T) {
-	a := NewEntry(nil)
+	a := NewLogger(LoggerConfig{Handler: NoopHandler, Level: InfoLevel}).WithLevel(InfoLevel)
 	b := a.WithError(fmt.Errorf("boom"))
 	qt.Assert(t, a.distinctFieldsLastByName(), qt.IsNil)
 	qt.Assert(t, b.distinctFieldsLastByName(), qt.DeepEquals, Fields{{"error", "boom"}})
 }
 
 func TestEntry_WithError_fields(t *testing.T) {
-	a := NewEntry(nil)
+	a := NewLogger(LoggerConfig{Handler: NoopHandler, Level: InfoLevel}).WithLevel(InfoLevel)
 	b := a.WithError(errFields("boom"))
 	qt.Assert(t, a.distinctFieldsLastByName(), qt.IsNil)
 	qt.Assert(t,
@@ -54,14 +54,14 @@ func TestEntry_WithError_fields(t *testing.T) {
 }
 
 func TestEntry_WithError_nil(t *testing.T) {
-	a := NewEntry(nil)
+	a := NewLogger(LoggerConfig{Handler: NoopHandler, Level: InfoLevel}).WithLevel(InfoLevel)
 	b := a.WithError(nil)
 	qt.Assert(t, a.distinctFieldsLastByName(), qt.IsNil)
 	qt.Assert(t, b.distinctFieldsLastByName(), qt.IsNil)
 }
 
 func TestEntry_WithDuration(t *testing.T) {
-	a := NewEntry(nil)
+	a := NewLogger(LoggerConfig{Handler: NoopHandler, Level: InfoLevel}).WithLevel(InfoLevel)
 	b := a.WithDuration(time.Second * 2)
 	qt.Assert(t, b.distinctFieldsLastByName(), qt.DeepEquals, Fields{{"duration", int64(2000)}})
 }

entry_test.go

@@ -5,15 +5,35 @@ import (
 	"time"
 )
 
-type Leveler interface {
+// Logger is the main interface for the logger.
+type Logger interface {
+	// WithLevel returns a new entry with `level` set.
 	WithLevel(Level) *EntryFields
 }
 
-type Logger interface {
-	Log(fmt.Stringer)
-	Leveler
-	WithFields(Fielder) *EntryFields
-	WithField(string, any) *EntryFields
+// LevelLogger
+type LevelLogger interface {
+	// Log logs a message at the given level using the string from calling s.String().
+	// Note that s.String() will not be called if the level is not enabled.
+	Log(s fmt.Stringer)
+
+	// WithLevel returns a new entry with `level` set.
+	WithLevel(Level) *EntryFields
+
+	// WithFields returns a new entry with the`fields` in fields set.
+	// This is a noop if LevelLogger's level is less than Logger's.
+	WithFields(fields Fielder) *EntryFields
+
+	// WithLevel returns a new entry with the field f set with value v
+	// This is a noop if LevelLogger's level is less than Logger's.
+	WithField(f string, v any) *EntryFields
+
+	// WithDuration returns a new entry with the "duration" field set
+	// to the given duration in milliseconds.
+	// This is a noop if LevelLogger's level is less than Logger's.
 	WithDuration(time.Duration) *EntryFields
+
+	// WithError returns a new entry with the "error" set to `err`.
+	// This is a noop if err is nil or  LevelLogger's level is less than Logger's.
 	WithError(error) *EntryFields
 }

interface.go

@@ -10,7 +10,7 @@ import (
 )
 
 // assert interface compliance.
-var _ Leveler = (*logger)(nil)
+var _ Logger = (*logger)(nil)
 
 // String implements fmt.Stringer and can be used directly in
 // the log methods.
@@ -92,7 +92,7 @@ type LoggerConfig struct {
 }
 
 // New returns a new logger.
-func NewLogger(cfg LoggerConfig) Leveler {
+func NewLogger(cfg LoggerConfig) Logger {
 	if cfg.Handler == nil {
 		panic("handler cannot be nil")
 	}

logger.go

@@ -130,7 +130,7 @@ func BenchmarkLogger_large(b *testing.B) {
 }
 
 func BenchmarkLogger_levels(b *testing.B) {
-	doWork := func(l log.Logger) {
+	doWork := func(l log.LevelLogger) {
 		for i := 0; i < 10; i++ {
 			l.Log(log.NewStringFunc(
 				func() string {