switch to slog.Logger for logging, for easier reuse of packages by external software

we don't want external software to include internal details like mlog.
slog.Logger is/will be the standard.

we still have mlog for its helper functions, and its handler that logs in
concise logfmt used by mox.

packages that are not meant for reuse still pass around mlog.Log for
convenience.

we use golang.org/x/exp/slog because we also support the previous Go toolchain
version. with the next Go release, we'll switch to the builtin slog.

moxio/bufpool.go

@@ -6,11 +6,11 @@ import (
 	"fmt"
 	"io"
 
+	"golang.org/x/exp/slog"
+
 	"github.com/mjl-/mox/mlog"
 )
 
-var xlog = mlog.New("moxio")
-
 // todo: instead of a bufpool, should maybe just make an alternative to bufio.Reader with a big enough buffer that we can fully use to read a line.
 
 var ErrLineTooLong = errors.New("line from remote too long") // Returned by Bufpool.Readline.
@@ -49,9 +49,9 @@ func (b *Bufpool) get() []byte {
 // be all the bytes that have been read in the buffer. If the pool is full, the
 // buffer is discarded, and will be cleaned up by the garbage collector.
 // The caller should no longer reference "buf" after a call to put.
-func (b *Bufpool) put(buf []byte, n int) {
+func (b *Bufpool) put(log mlog.Log, buf []byte, n int) {
 	if len(buf) != b.size {
-		xlog.Error("buffer with bad size returned, ignoring", mlog.Field("badsize", len(buf)), mlog.Field("expsize", b.size))
+		log.Error("buffer with bad size returned, ignoring", slog.Int("badsize", len(buf)), slog.Int("expsize", b.size))
 		return
 	}
 
@@ -67,11 +67,11 @@ func (b *Bufpool) put(buf []byte, n int) {
 // Readline reads a \n- or \r\n-terminated line. Line is returned without \n or \r\n.
 // If the line was too long, ErrLineTooLong is returned.
 // If an EOF is encountered before a \n, io.ErrUnexpectedEOF is returned.
-func (b *Bufpool) Readline(r *bufio.Reader) (line string, rerr error) {
+func (b *Bufpool) Readline(log mlog.Log, r *bufio.Reader) (line string, rerr error) {
 	var nread int
 	buf := b.get()
 	defer func() {
-		b.put(buf, nread)
+		b.put(log, buf, nread)
 	}()
 
 	// Read until newline. If we reach the end of the buffer first, we write back an

moxio/bufpool_test.go

@@ -7,6 +7,8 @@ import (
 	"io"
 	"strings"
 	"testing"
+
+	"github.com/mjl-/mox/mlog"
 )
 
 func TestBufpool(t *testing.T) {
@@ -16,8 +18,9 @@ func TestBufpool(t *testing.T) {
 	for i := 0; i < len(a); i++ {
 		a[i] = 1
 	}
-	bp.put(a, len(a)) // Will be stored.
-	bp.put(b, 0)      // Will be discarded.
+	log := mlog.New("moxio", nil)
+	bp.put(log, a, len(a)) // Will be stored.
+	bp.put(log, b, 0)      // Will be discarded.
 	na := bp.get()
 	if fmt.Sprintf("%p", a) != fmt.Sprintf("%p", na) {
 		t.Fatalf("received unexpected new buf %p != %p", a, na)
@@ -28,22 +31,22 @@ func TestBufpool(t *testing.T) {
 		}
 	}
 
-	if _, err := bp.Readline(bufio.NewReader(strings.NewReader("this is too long"))); !errors.Is(err, ErrLineTooLong) {
+	if _, err := bp.Readline(log, bufio.NewReader(strings.NewReader("this is too long"))); !errors.Is(err, ErrLineTooLong) {
 		t.Fatalf("expected ErrLineTooLong, got error %v", err)
 	}
-	if _, err := bp.Readline(bufio.NewReader(strings.NewReader("short"))); !errors.Is(err, io.ErrUnexpectedEOF) {
+	if _, err := bp.Readline(log, bufio.NewReader(strings.NewReader("short"))); !errors.Is(err, io.ErrUnexpectedEOF) {
 		t.Fatalf("expected ErrLineTooLong, got error %v", err)
 	}
 
 	er := errReader{fmt.Errorf("bad")}
-	if _, err := bp.Readline(bufio.NewReader(er)); err == nil || !errors.Is(err, er.err) {
+	if _, err := bp.Readline(log, bufio.NewReader(er)); err == nil || !errors.Is(err, er.err) {
 		t.Fatalf("got unexpected error %s", err)
 	}
 
-	if line, err := bp.Readline(bufio.NewReader(strings.NewReader("ok\r\n"))); line != "ok" {
+	if line, err := bp.Readline(log, bufio.NewReader(strings.NewReader("ok\r\n"))); line != "ok" {
 		t.Fatalf(`got %q, err %v, expected line "ok"`, line, err)
 	}
-	if line, err := bp.Readline(bufio.NewReader(strings.NewReader("ok\n"))); line != "ok" {
+	if line, err := bp.Readline(log, bufio.NewReader(strings.NewReader("ok\n"))); line != "ok" {
 		t.Fatalf(`got %q, err %v, expected line "ok"`, line, err)
 	}
 }

moxio/linkcopy.go

@@ -5,6 +5,8 @@ import (
 	"io"
 	"os"
 
+	"golang.org/x/exp/slog"
+
 	"github.com/mjl-/mox/mlog"
 )
 
@@ -14,7 +16,7 @@ import (
 // ensure the file is written on disk. Callers should also sync the directory of
 // the destination file, but may want to do that after linking/copying multiple
 // files. If dst was created and an error occurred, it is removed.
-func LinkOrCopy(log *mlog.Log, dst, src string, srcReaderOpt io.Reader, sync bool) (rerr error) {
+func LinkOrCopy(log mlog.Log, dst, src string, srcReaderOpt io.Reader, sync bool) (rerr error) {
 	// Try hardlink first.
 	err := os.Link(src, dst)
 	if err == nil {
@@ -48,7 +50,7 @@ func LinkOrCopy(log *mlog.Log, dst, src string, srcReaderOpt io.Reader, sync boo
 			err := df.Close()
 			log.Check(err, "closing partial destination file")
 			err = os.Remove(dst)
-			log.Check(err, "removing partial destination file", mlog.Field("path", dst))
+			log.Check(err, "removing partial destination file", slog.String("path", dst))
 		}
 	}()
 
@@ -64,7 +66,7 @@ func LinkOrCopy(log *mlog.Log, dst, src string, srcReaderOpt io.Reader, sync boo
 	df = nil
 	if err != nil {
 		err := os.Remove(dst)
-		log.Check(err, "removing partial destination file", mlog.Field("path", dst))
+		log.Check(err, "removing partial destination file", slog.String("path", dst))
 		return err
 	}
 	return nil

moxio/linkcopy_test.go

@@ -17,7 +17,7 @@ func tcheckf(t *testing.T, err error, format string, args ...any) {
 }
 
 func TestLinkOrCopy(t *testing.T) {
-	log := mlog.New("linkorcopy")
+	log := mlog.New("linkorcopy", nil)
 
 	// link in same directory. file exists error. link to file in non-existent
 	// directory (exists error). link to file in system temp dir (hopefully other file

moxio/syncdir.go

@@ -5,16 +5,18 @@ package moxio
 import (
 	"fmt"
 	"os"
+
+	"github.com/mjl-/mox/mlog"
 )
 
 // SyncDir opens a directory and syncs its contents to disk.
-func SyncDir(dir string) error {
+func SyncDir(log mlog.Log, dir string) error {
 	d, err := os.Open(dir)
 	if err != nil {
 		return fmt.Errorf("open directory: %v", err)
 	}
 	err = d.Sync()
 	xerr := d.Close()
-	xlog.Check(xerr, "closing directory after sync")
+	log.Check(xerr, "closing directory after sync")
 	return err
 }

moxio/trace.go

@@ -3,43 +3,45 @@ package moxio
 import (
 	"io"
 
+	"golang.org/x/exp/slog"
+
 	"github.com/mjl-/mox/mlog"
 )
 
 type TraceWriter struct {
-	log    *mlog.Log
+	log    mlog.Log
 	prefix string
 	w      io.Writer
-	level  mlog.Level
+	level  slog.Level
 }
 
 // NewTraceWriter wraps "w" into a writer that logs all writes to "log" with
 // log level trace, prefixed with "prefix".
-func NewTraceWriter(log *mlog.Log, prefix string, w io.Writer) *TraceWriter {
+func NewTraceWriter(log mlog.Log, prefix string, w io.Writer) *TraceWriter {
 	return &TraceWriter{log, prefix, w, mlog.LevelTrace}
 }
 
 // Write logs a trace line for writing buf to the client, then writes to the
 // client.
 func (w *TraceWriter) Write(buf []byte) (int, error) {
-	w.log.Trace(w.level, w.prefix+string(buf))
+	w.log.Trace(w.level, w.prefix, buf)
 	return w.w.Write(buf)
 }
 
-func (w *TraceWriter) SetTrace(level mlog.Level) {
+func (w *TraceWriter) SetTrace(level slog.Level) {
 	w.level = level
 }
 
 type TraceReader struct {
-	log    *mlog.Log
+	log    mlog.Log
 	prefix string
 	r      io.Reader
-	level  mlog.Level
+	level  slog.Level
 }
 
 // NewTraceReader wraps reader "r" into a reader that logs all reads to "log"
 // with log level trace, prefixed with "prefix".
-func NewTraceReader(log *mlog.Log, prefix string, r io.Reader) *TraceReader {
+func NewTraceReader(log mlog.Log, prefix string, r io.Reader) *TraceReader {
 	return &TraceReader{log, prefix, r, mlog.LevelTrace}
 }
 
@@ -48,11 +50,11 @@ func NewTraceReader(log *mlog.Log, prefix string, r io.Reader) *TraceReader {
 func (r *TraceReader) Read(buf []byte) (int, error) {
 	n, err := r.r.Read(buf)
 	if n > 0 {
-		r.log.Trace(r.level, r.prefix+string(buf[:n]))
+		r.log.Trace(r.level, r.prefix, buf[:n])
 	}
 	return n, err
 }
 
-func (r *TraceReader) SetTrace(level mlog.Level) {
+func (r *TraceReader) SetTrace(level slog.Level) {
 	r.level = level
 }