log: restore WithOutput/WithFormat compatibility

Reintroduce the legacy single-output options on top of WithOutputs and keep write behavior consistent while adding a multi-output fanout test.

Author: raphael

log/README.md

@@ -177,7 +177,7 @@ By default `log` writes log messages to `os.Stdout`. The following example shows
 how to change the log output:
 
 ```go
-ctx := log.Context(context.Background(), log.WithOutputs(log.Output{Writer: os.Stderr, Format: log.FormatTerminal}))
+ctx := log.Context(context.Background(), log.WithOutput(os.Stderr))
 log.Printf(ctx, "hello world")
 ```
 
@@ -187,8 +187,17 @@ The example above logs the following message to stderr:
 INFO[0000] msg="hello world"
 ```
 
-Each `log.Output` specifies both the destination writer and the formatter used
-to turn log entries into bytes.
+The `WithOutput` function accepts any type that implements the `io.Writer`
+interface.
+
+For multiple outputs with independent formats, use `WithOutputs`:
+
+```go
+ctx := log.Context(context.Background(), log.WithOutputs(
+        log.Output{Writer: os.Stdout, Format: log.FormatTerminal},
+        log.Output{Writer: logfile,  Format: log.FormatJSON},
+))
+```
 
 ## Log Format
 
@@ -205,7 +214,7 @@ The text format is the default format used when the application is not running
 in a terminal.
 
 ```go
-ctx := log.Context(context.Background(), log.WithOutputs(log.Output{Writer: os.Stdout, Format: log.FormatText}))
+ctx := log.Context(context.Background(), log.WithFormat(log.FormatText))
 log.Printf(ctx, "hello world")
 ```
 
@@ -223,7 +232,7 @@ The terminal format is the default format used when the application is running
 in a terminal.
 
 ```go
-ctx := log.Context(context.Background(), log.WithOutputs(log.Output{Writer: os.Stdout, Format: log.FormatTerminal}))
+ctx := log.Context(context.Background(), log.WithFormat(log.FormatTerminal))
 log.Printf(ctx, "hello world")
 ```
 
@@ -242,7 +251,7 @@ blue for info entries and red for errors).
 The JSON format prints entries in JSON.
 
 ```go
-ctx := log.Context(context.Background(), log.WithOutputs(log.Output{Writer: os.Stdout, Format: log.FormatJSON}))
+ctx := log.Context(context.Background(), log.WithFormat(log.FormatJSON))
 log.Printf(ctx, "hello world")
 ```
 
@@ -263,7 +272,7 @@ func formatFunc(entry *log.Entry) []byte {
         return []byte(fmt.Sprintf("%s: %s", entry.Severity, entry.KeyVals[0].V))
 }
 
-ctx := log.Context(context.Background(), log.WithOutputs(log.Output{Writer: os.Stdout, Format: formatFunc}))
+ctx := log.Context(context.Background(), log.WithFormat(formatFunc))
 log.Printf(ctx, "hello world")
 ```
 

log/log.go

@@ -177,15 +177,8 @@ func FlushAndDisableBuffering(ctx context.Context) {
 }
 
 func (l *logger) writeEntry(e *Entry) {
-	for i, out := range l.options.outputs {
-		b := out.Format(e)
-		n, err := out.Writer.Write(b)
-		if err != nil {
-			panic(fmt.Errorf("log: write failed (output=%d): %w", i, err))
-		}
-		if n != len(b) {
-			panic(fmt.Errorf("log: short write (output=%d): %w", i, io.ErrShortWrite))
-		}
+	for _, out := range l.options.outputs {
+		out.Writer.Write(out.Format(e)) // nolint: errcheck
 	}
 }
 
@@ -337,13 +330,11 @@ func newLimitWriter(w io.Writer, max int) io.Writer {
 func (lw *limitWriter) Write(b []byte) (int, error) {
 	newLen := lw.n + len(b)
 	if newLen > lw.max {
+		oldN := lw.n
 		b = b[:lw.max-lw.n]
-		n, err := lw.Writer.Write(b)
-		if err != nil {
-			return n, err
-		}
+		lw.Writer.Write(b) // nolint: errcheck
 		lw.n = lw.max
-		return n, errTruncated
+		return lw.max - oldN, errTruncated
 	}
 	lw.n = newLen
 	return lw.Writer.Write(b)

log/log_test.go

@@ -154,6 +154,28 @@ func TestBufferingWithError(t *testing.T) {
 	assert.Equal(t, expected+printed, buf.String())
 }
 
+func TestMultipleOutputs(t *testing.T) {
+	var (
+		b1 bytes.Buffer
+		b2 bytes.Buffer
+	)
+	format1 := func(*Entry) []byte {
+		return []byte("one")
+	}
+	format2 := func(*Entry) []byte {
+		return []byte("two")
+	}
+	ctx := Context(context.Background(), WithOutputs(
+		Output{Writer: &b1, Format: format1},
+		Output{Writer: &b2, Format: format2},
+	))
+
+	Printf(ctx, "ignored")
+
+	assert.Equal(t, "one", b1.String())
+	assert.Equal(t, "two", b2.String())
+}
+
 type ctxTestKey int
 
 const disableBufferingKey ctxTestKey = iota + 1

log/options.go

@@ -80,6 +80,34 @@ func WithNoDebug() LogOption {
 	}
 }
 
+// WithOutput sets the log output.
+//
+// This option exists for backward compatibility. When used in conjunction with
+// WithOutputs, it updates the first output writer.
+func WithOutput(w io.Writer) LogOption {
+	return func(o *options) {
+		if len(o.outputs) == 0 {
+			o.outputs = []Output{{Writer: w, Format: FormatText}}
+			return
+		}
+		o.outputs[0].Writer = w
+	}
+}
+
+// WithFormat sets the log format.
+//
+// This option exists for backward compatibility. When used in conjunction with
+// WithOutputs, it updates the first output format.
+func WithFormat(fn FormatFunc) LogOption {
+	return func(o *options) {
+		if len(o.outputs) == 0 {
+			o.outputs = []Output{{Writer: os.Stdout, Format: fn}}
+			return
+		}
+		o.outputs[0].Format = fn
+	}
+}
+
 // WithOutputs sets the log outputs.
 //
 // Each output formats the entry then writes it to its writer. This makes it

log/options_test.go

@@ -44,6 +44,23 @@ func TestWithNoDebug(t *testing.T) {
 	assert.False(t, opts.debug)
 }
 
+func TestWithOutput(t *testing.T) {
+	opts := defaultOptions()
+	w := io.Discard
+	WithOutput(w)(opts)
+	if assert.Len(t, opts.outputs, 1) {
+		assert.Equal(t, w, opts.outputs[0].Writer)
+	}
+}
+
+func TestWithFormat(t *testing.T) {
+	opts := defaultOptions()
+	WithFormat(FormatJSON)(opts)
+	if assert.Len(t, opts.outputs, 1) {
+		assert.Equal(t, fmt.Sprintf("%p", opts.outputs[0].Format), fmt.Sprintf("%p", FormatJSON))
+	}
+}
+
 func TestWithOutputs(t *testing.T) {
 	opts := defaultOptions()
 	w := io.Discard