(refactor): prepare breaking v2 API

- rename package to sneklog and move module to /v2
- replace text output flags with writer formatters
- remove external color dependencies
- update migration notes and coverage

writers.go

@@ -1,4 +1,4 @@
-package slog
+package sneklog
 
 import (
 	"encoding/json"
@@ -20,10 +20,20 @@ type LoggerWriter interface {
 // LoggerTextWriter writes human-readable log records to an io.Writer.
 type LoggerTextWriter struct {
 	LoggerWriter
-	writer         io.Writer
-	closer         io.Closer
-	printTraceback bool
-	printTime      bool
+	writer    io.Writer
+	closer    io.Closer
+	formatter *Formatter
+}
+
+func (w *LoggerTextWriter) SetFormatter(formatter *Formatter) *LoggerTextWriter {
+	w.formatter = formatter
+	return w
+}
+func (w *LoggerTextWriter) Formatter() *Formatter {
+	if w.formatter == nil {
+		return DefaultTextFormatter
+	}
+	return w.formatter
 }
 
 // Write forwards raw bytes to the underlying writer.
@@ -32,10 +42,32 @@ func (w *LoggerTextWriter) Write(p []byte) (n int, err error) {
 }
 
 // Print formats the provided record as text and writes it to the underlying writer.
-func (w *LoggerTextWriter) Print(level LogLevel, prefix string, _ []*MethodTraceback, messages ...any) error {
-	s := BuildString(level, prefix, w.printTime, w.printTraceback, messages...)
+func (w *LoggerTextWriter) Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error {
+	msg := Map(messages, func(el any) string { return fmt.Sprint(el) })
+	newline := false
+	if len(msg) > 0 && strings.HasSuffix(msg[len(msg)-1], "\n") {
+		newline = true
+		msg[len(msg)-1] = strings.TrimSuffix(msg[len(msg)-1], "\n")
+	}
+	messages = Map(msg, func(el string) any { return any(el) })
+
+	f := w.Formatter()
+	s := f.FormatMessage(level, prefix, traceback, messages...)
+	if f.ColorOutput && (!f.ColorOnlyStdout || w.writer == os.Stdout || w.writer == os.Stderr) {
+		s = f.ColorizeString(s, level)
+	}
+
 	_, err := w.Write([]byte(s))
-	return err
+	if err != nil {
+		return err
+	}
+	if newline {
+		_, err = w.Write([]byte("\n"))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 // Close closes the owned writer, if any.
@@ -52,14 +84,28 @@ type LoggerJsonWriter struct {
 	writer io.Writer
 	closer io.Closer
 	pretty bool
+
+	formatter *Formatter
+}
+
+func (w *LoggerJsonWriter) Formatter() *Formatter {
+	if w.formatter == nil {
+		return DefaultJsonFormatter
+	}
+	return w.formatter
+}
+func (w *LoggerJsonWriter) SetFormatter(f *Formatter) *LoggerJsonWriter {
+	w.formatter = f
+	return w
 }
 
 // LoggerJsonMessage is the JSON payload emitted by LoggerJsonWriter.
 type LoggerJsonMessage struct {
-	Time      time.Time          `json:"time"`
-	Level     string             `json:"level"`
-	Prefix    string             `json:"prefix"`
-	Message   string             `json:"message"`
+	Time    string `json:"time"`
+	Level   string `json:"level"`
+	Prefix  string `json:"prefix"`
+	Message string `json:"message"`
+
 	Traceback []*MethodTraceback `json:"traceback"`
 }
 
@@ -71,18 +117,24 @@ func (w *LoggerJsonWriter) Write(data []byte) (int, error) {
 // Print encodes the provided record as JSON and writes it to the underlying writer.
 func (w *LoggerJsonWriter) Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error {
 	msg := Map(messages, func(el any) string { return fmt.Sprint(el) })
-
 	newline := false
 	if len(msg) > 0 && strings.HasSuffix(msg[len(msg)-1], "\n") {
 		newline = true
 		msg[len(msg)-1] = strings.TrimSuffix(msg[len(msg)-1], "\n")
 	}
+	messages = Map(msg, func(el string) any { return any(el) })
+
+	f := w.Formatter()
+	s := f.FormatMessage(level, prefix, traceback, messages...)
+	if f.ColorOutput && (!f.ColorOnlyStdout || w.writer == os.Stdout || w.writer == os.Stderr) {
+		s = f.ColorizeString(s, level)
+	}
 
 	m := LoggerJsonMessage{
-		Time:      time.Now(),
+		Time:      f.FormatTime(time.Now()),
 		Level:     level.GetName(),
 		Prefix:    prefix,
-		Message:   strings.TrimSpace(strings.Join(msg, " ")),
+		Message:   s,
 		Traceback: traceback,
 	}
 	var data []byte
@@ -112,16 +164,16 @@ func (w *LoggerJsonWriter) Close() error {
 
 // CreateTextWriter wraps an external writer for text output without taking
 // ownership of it.
-func CreateTextWriter(w io.Writer, printTraceback, printTime bool) *LoggerTextWriter {
+func CreateTextWriter(w io.Writer) *LoggerTextWriter {
 	writer := &LoggerTextWriter{
-		writer: w, printTraceback: printTraceback, printTime: printTime,
+		writer: w,
 	}
 	return writer
 }
 
 // CreateTextFileWriter creates a text writer for path, creating parent
 // directories as needed. The returned writer owns the opened file.
-func CreateTextFileWriter(path string, printTraceback, printTime bool) (*LoggerTextWriter, error) {
+func CreateTextFileWriter(path string) (*LoggerTextWriter, error) {
 	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
 	if err != nil {
 		return nil, err
@@ -130,15 +182,15 @@ func CreateTextFileWriter(path string, printTraceback, printTime bool) (*LoggerT
 	if err != nil {
 		return nil, err
 	}
-	writer := CreateTextWriter(file, printTraceback, printTime)
+	writer := CreateTextWriter(file)
 	writer.closer = file
 	return writer, nil
 }
 
 // CreateTextStdoutWriter creates a text writer for os.Stdout without taking
 // ownership of stdout.
-func CreateTextStdoutWriter(printTraceback, printTime bool) *LoggerTextWriter {
-	writer := CreateTextWriter(os.Stdout, printTraceback, printTime)
+func CreateTextStdoutWriter() *LoggerTextWriter {
+	writer := CreateTextWriter(os.Stdout)
 	writer.closer = nil
 	return writer
 }