Split Entry into Entry and EntryFields

Also remove the now incompatible Trace method.

This is easier to reason about and saves some memory allocations:

```bash
name              old time/op    new time/op    delta
Logger_small-10     84.1ns ± 4%    81.6ns ± 4%     ~     (p=0.200 n=4+4)
Logger_medium-10     234ns ± 0%     217ns ± 0%   -6.86%  (p=0.029 n=4+4)
Logger_large-10      623ns ± 1%     583ns ± 0%   -6.38%  (p=0.029 n=4+4)

name              old alloc/op   new alloc/op   delta
Logger_small-10       224B ± 0%      144B ± 0%  -35.71%  (p=0.029 n=4+4)
Logger_medium-10      536B ± 0%      456B ± 0%  -14.93%  (p=0.029 n=4+4)
Logger_large-10     1.86kB ± 0%    1.69kB ± 0%   -9.44%  (p=0.029 n=4+4)

name              old allocs/op  new allocs/op  delta
Logger_small-10       2.00 ± 0%      2.00 ± 0%     ~     (all equal)
Logger_medium-10      6.00 ± 0%      6.00 ± 0%     ~     (all equal)
Logger_large-10       11.0 ± 0%      11.0 ± 0%     ~     (all equal)
```

Author: bep

entry.go

@@ -1,57 +1,81 @@
 package log
 
 import (
+	"encoding/json"
 	"fmt"
 	"os"
 	"strings"
 	"time"
 )
 
 // assert interface compliance.
-var _ Interface = (*Entry)(nil)
+var _ Interface = (*EntryFields)(nil)
 
 // Now returns the current time.
 var Now = time.Now
 
-// Entry represents a single log entry.
+// EntryFields represents a single log entry.
+type EntryFields struct {
+	Logger *Logger `json:"-"`
+	Fields Fields  `json:"-"`
+	start  time.Time
+}
+
+// Entry holds a Entry with a Message, Timestamp and a Level.
+// This is what is actually logged.
 type Entry struct {
-	Logger    *Logger   `json:"-"`
-	Fields    Fields    `json:"fields"`
-	Level     Level     `json:"level"`
-	Timestamp time.Time `json:"timestamp"`
-	Message   string    `json:"message"`
-	start     time.Time
+	*EntryFields
+	FieldsUnique Fields    `json:"-"`
+	Level        Level     `json:"level"`
+	Timestamp    time.Time `json:"timestamp"`
+	Message      string    `json:"message"`
+}
+
+func (e Entry) MarshalJSON() ([]byte, error) {
+	fields := make(map[string]any)
+	for _, f := range e.FieldsUnique {
+		fields[f.Name] = f.Value
+	}
+
+	type EntryAlias Entry
+	return json.Marshal(&struct {
+		Fields map[string]any `json:"fields"`
+		EntryAlias
+	}{
+		Fields:     fields,
+		EntryAlias: (EntryAlias)(e),
+	})
 }
 
 // NewEntry returns a new entry for `log`.
-func NewEntry(log *Logger) *Entry {
-	return &Entry{
+func NewEntry(log *Logger) *EntryFields {
+	return &EntryFields{
 		Logger: log,
 	}
 }
 
 // WithFields returns a new entry with `fields` set.
-func (e Entry) WithFields(fielder Fielder) *Entry {
+func (e EntryFields) WithFields(fielder Fielder) *EntryFields {
 	e.Fields = append(e.Fields, fielder.Fields()...)
 	return &e
 }
 
 // WithField returns a new entry with the `key` and `value` set.
-func (e *Entry) WithField(key string, value any) *Entry {
+func (e *EntryFields) WithField(key string, value any) *EntryFields {
 	return e.WithFields(Fields{{key, value}})
 }
 
 // WithDuration returns a new entry with the "duration" field set
 // to the given duration in milliseconds.
-func (e *Entry) WithDuration(d time.Duration) *Entry {
+func (e *EntryFields) WithDuration(d time.Duration) *EntryFields {
 	return e.WithField("duration", d.Milliseconds())
 }
 
 // WithError returns a new entry with the "error" set to `err`.
 //
 // The given error may implement .Fielder, if it does the method
 // will add all its `.Fields()` into the returned entry.
-func (e *Entry) WithError(err error) *Entry {
+func (e *EntryFields) WithError(err error) *EntryFields {
 	if err == nil {
 		return e
 	}
@@ -81,78 +105,58 @@ func (e *Entry) WithError(err error) *Entry {
 }
 
 // Debug level message.
-func (e *Entry) Debug(msg string) {
+func (e *EntryFields) Debug(msg string) {
 	e.Logger.log(DebugLevel, e, msg)
 }
 
 // Info level message.
-func (e *Entry) Info(msg string) {
+func (e *EntryFields) Info(msg string) {
 	e.Logger.log(InfoLevel, e, msg)
 }
 
 // Warn level message.
-func (e *Entry) Warn(msg string) {
+func (e *EntryFields) Warn(msg string) {
 	e.Logger.log(WarnLevel, e, msg)
 }
 
 // Error level message.
-func (e *Entry) Error(msg string) {
+func (e *EntryFields) Error(msg string) {
 	e.Logger.log(ErrorLevel, e, msg)
 }
 
 // Fatal level message, followed by an exit.
-func (e *Entry) Fatal(msg string) {
+func (e *EntryFields) Fatal(msg string) {
 	e.Logger.log(FatalLevel, e, msg)
 	os.Exit(1)
 }
 
 // Debugf level formatted message.
-func (e *Entry) Debugf(msg string, v ...any) {
+func (e *EntryFields) Debugf(msg string, v ...any) {
 	e.Debug(fmt.Sprintf(msg, v...))
 }
 
 // Infof level formatted message.
-func (e *Entry) Infof(msg string, v ...any) {
+func (e *EntryFields) Infof(msg string, v ...any) {
 	e.Info(fmt.Sprintf(msg, v...))
 }
 
 // Warnf level formatted message.
-func (e *Entry) Warnf(msg string, v ...any) {
+func (e *EntryFields) Warnf(msg string, v ...any) {
 	e.Warn(fmt.Sprintf(msg, v...))
 }
 
 // Errorf level formatted message.
-func (e *Entry) Errorf(msg string, v ...any) {
+func (e *EntryFields) Errorf(msg string, v ...any) {
 	e.Error(fmt.Sprintf(msg, v...))
 }
 
 // Fatalf level formatted message, followed by an exit.
-func (e *Entry) Fatalf(msg string, v ...any) {
+func (e *EntryFields) Fatalf(msg string, v ...any) {
 	e.Fatal(fmt.Sprintf(msg, v...))
 }
 
-// Trace returns a new entry with a Stop method to fire off
-// a corresponding completion log, useful with defer.
-func (e *Entry) Trace(msg string) *Entry {
-	e.Info(msg)
-	v := e.WithFields(e.Fields)
-	v.Message = msg
-	v.start = time.Now()
-	return v
-}
-
-// Stop should be used with Trace, to fire off the completion message. When
-// an `err` is passed the "error" field is set, and the log level is error.
-func (e *Entry) Stop(err *error) {
-	if err == nil || *err == nil {
-		e.WithDuration(time.Since(e.start)).Info(e.Message)
-	} else {
-		e.WithDuration(time.Since(e.start)).WithError(*err).Error(e.Message)
-	}
-}
-
 // mergedFields returns the fields list collapsed into a single slice.
-func (e *Entry) mergedFields() Fields {
+func (e *EntryFields) mergedFields() Fields {
 	fields := make(Fields, 0, len(e.Fields))
 	for i := len(e.Fields) - 1; i >= 0; i-- {
 		f := e.Fields[i]
@@ -176,12 +180,12 @@ func (e *Entry) mergedFields() Fields {
 }
 
 // finalize returns a copy of the Entry with Fields merged.
-func (e *Entry) finalize(level Level, msg string) *Entry {
+func (e *EntryFields) finalize(level Level, msg string) *Entry {
 	return &Entry{
-		Logger:    e.Logger,
-		Fields:    e.mergedFields(),
-		Level:     level,
-		Message:   msg,
-		Timestamp: Now(),
+		EntryFields:  e,
+		FieldsUnique: e.mergedFields(),
+		Level:        level,
+		Message:      msg,
+		Timestamp:    Now(),
 	}
 }

handlers/cli/cli.go

@@ -67,7 +67,7 @@ func (h *Handler) HandleLog(e *log.Entry) error {
 
 	color.Fprintf(h.Writer, "%s %-25s", bold.Sprintf("%*s", h.Padding+1, level), e.Message)
 
-	for _, field := range e.Fields {
+	for _, field := range e.FieldsUnique {
 		if field.Name == "source" {
 			continue
 		}

handlers/json/json_test.go

@@ -17,8 +17,7 @@ func init() {
 	}
 }
 
-// TODO(bep) fix me.
-func _Test(t *testing.T) {
+func Test(t *testing.T) {
 	var buf bytes.Buffer
 
 	log.SetHandler(json.New(&buf))

handlers/text/text.go

@@ -69,7 +69,7 @@ func (h *Handler) HandleLog(e *log.Entry) error {
 	ts := time.Since(start) / time.Second
 	fmt.Fprintf(h.Writer, "\033[%dm%6s\033[0m[%04d] %-25s", color, level, ts, e.Message)
 
-	for _, f := range e.Fields {
+	for _, f := range e.FieldsUnique {
 		fmt.Fprintf(h.Writer, " \033[%dm%s\033[0m=%v", color, f.Name, f.Value)
 	}
 

handlers/text/text_test.go

@@ -17,16 +17,15 @@ func init() {
 	}
 }
 
-// TODO(bep) fix me.
-func _Test(t *testing.T) {
+func TestTextHandler(t *testing.T) {
 	var buf bytes.Buffer
 
 	log.SetHandler(text.New(&buf))
 	log.WithField("user", "tj").WithField("id", "123").Info("hello")
 	log.WithField("user", "tj").Info("world")
 	log.WithField("user", "tj").Error("boom")
 
-	expected := "\x1b[34m  INFO\x1b[0m[0000] hello                     \x1b[34mid\x1b[0m=123 \x1b[34muser\x1b[0m=tj\n\x1b[34m  INFO\x1b[0m[0000] world                     \x1b[34muser\x1b[0m=tj\n\x1b[31m ERROR\x1b[0m[0000] boom                      \x1b[31muser\x1b[0m=tj\n"
+	expected := "\x1b[34m  INFO\x1b[0m[0000] hello                     \x1b[34muser\x1b[0m=tj \x1b[34mid\x1b[0m=123\n\x1b[34m  INFO\x1b[0m[0000] world                     \x1b[34muser\x1b[0m=tj\n\x1b[31m ERROR\x1b[0m[0000] boom                      \x1b[31muser\x1b[0m=tj\n"
 
 	qt.Assert(t, buf.String(), qt.Equals, expected)
 }

interface.go

@@ -4,10 +4,10 @@ import "time"
 
 // Interface represents the API of both Logger and Entry.
 type Interface interface {
-	WithFields(Fielder) *Entry
-	WithField(string, any) *Entry
-	WithDuration(time.Duration) *Entry
-	WithError(error) *Entry
+	WithFields(Fielder) *EntryFields
+	WithField(string, any) *EntryFields
+	WithDuration(time.Duration) *EntryFields
+	WithError(error) *EntryFields
 	Debug(string)
 	Info(string)
 	Warn(string)
@@ -18,5 +18,4 @@ type Interface interface {
 	Warnf(string, ...any)
 	Errorf(string, ...any)
 	Fatalf(string, ...any)
-	Trace(string) *Entry
 }

levels_test.go

@@ -38,20 +38,20 @@ func TestParseLevel(t *testing.T) {
 
 func TestLevel_MarshalJSON(t *testing.T) {
 	e := Entry{
-		Level:   InfoLevel,
-		Message: "hello",
-		Fields:  Fields{},
+		Level:       InfoLevel,
+		Message:     "hello",
+		EntryFields: &EntryFields{},
 	}
 
-	expect := `{"fields":[],"level":"info","timestamp":"0001-01-01T00:00:00Z","message":"hello"}`
+	expect := `{"fields":{},"level":"info","timestamp":"0001-01-01T00:00:00Z","message":"hello"}`
 
 	b, err := json.Marshal(e)
 	qt.Assert(t, err, qt.IsNil)
 	qt.Assert(t, string(b), qt.Equals, expect)
 }
 
 func TestLevel_UnmarshalJSON(t *testing.T) {
-	s := `{"fields":[],"level":"info","timestamp":"0001-01-01T00:00:00Z","message":"hello"}`
+	s := `{"fields":{},"level":"info","timestamp":"0001-01-01T00:00:00Z","message":"hello"}`
 	e := new(Entry)
 
 	err := json.Unmarshal([]byte(s), e)

logger.go

@@ -53,26 +53,26 @@ type Logger struct {
 }
 
 // WithFields returns a new entry with `fields` set.
-func (l *Logger) WithFields(fields Fielder) *Entry {
+func (l *Logger) WithFields(fields Fielder) *EntryFields {
 	return NewEntry(l).WithFields(fields.Fields())
 }
 
 // WithField returns a new entry with the `key` and `value` set.
 //
 // Note that the `key` should not have spaces in it - use camel
 // case or underscores
-func (l *Logger) WithField(key string, value any) *Entry {
+func (l *Logger) WithField(key string, value any) *EntryFields {
 	return NewEntry(l).WithField(key, value)
 }
 
 // WithDuration returns a new entry with the "duration" field set
 // to the given duration in milliseconds.
-func (l *Logger) WithDuration(d time.Duration) *Entry {
+func (l *Logger) WithDuration(d time.Duration) *EntryFields {
 	return NewEntry(l).WithDuration(d)
 }
 
 // WithError returns a new entry with the "error" set to `err`.
-func (l *Logger) WithError(err error) *Entry {
+func (l *Logger) WithError(err error) *EntryFields {
 	return NewEntry(l).WithError(err)
 }
 
@@ -126,16 +126,10 @@ func (l *Logger) Fatalf(msg string, v ...any) {
 	NewEntry(l).Fatalf(msg, v...)
 }
 
-// Trace returns a new entry with a Stop method to fire off
-// a corresponding completion log, useful with defer.
-func (l *Logger) Trace(msg string) *Entry {
-	return NewEntry(l).Trace(msg)
-}
-
 // log the message, invoking the handler. We clone the entry here
 // to bypass the overhead in Entry methods when the level is not
 // met.
-func (l *Logger) log(level Level, e *Entry, msg string) {
+func (l *Logger) log(level Level, e *EntryFields, msg string) {
 	if level < l.Level {
 		return
 	}