fix: return the smallest write from multiWriteSyncer - #1590

A WriteSyncer built from several sinks reports a full write even when one of
the sinks wrote nothing.

ws, _, _ := zap.Open("stdout", "/var/log/app.log")
// ...the log file's descriptor is later closed, or the disk fills up,
// so that sink's Write returns (0, err).

n, err := ws.Write(payload)  // n == len(payload), not 0

Writing to a closed or full file returns (0, err), which is the normal
short-write signal. multiWriteSyncer drops it: n comes back as the count
from whichever sink happened to be listed later. Callers that use the syncer as
the plain io.Writer it embeds — io.Copy, fmt.Fprint — then account for
bytes that were never written.

Cause

Write is documented directly above its own definition:

// When not all underlying syncers write the same number of bytes,
// the smallest number is returned even though Write() is called on
// all of them.
func (ws multiWriteSyncer) Write(p []byte) (int, error) {
	var writeErr error
	nWritten := 0
	for _, w := range ws {
		n, err := w.Write(p)
		writeErr = multierr.Append(writeErr, err)
		if nWritten == 0 && n != 0 {
			nWritten = n
		} else if n < nWritten {
			nWritten = n
		}
	}
	return nWritten, writeErr
}

nWritten == 0 is used to mean "nothing recorded yet", but 0 is also a
legitimate minimum. Once the running minimum is 0, the first branch matches
again on the next syncer and overwrites it. So a 0 only survives if it comes
from the last syncer:

Fix

Seed the minimum from the first syncer instead of from the zero value, so 0 is
carried through like any other count. An empty multiWriteSyncer still returns
0, unchanged.

Tests

TestMultiWriteSyncerReturnsSmallestWrite covers the five rows above.

Before, on unmodified master:

=== RUN   TestMultiWriteSyncerReturnsSmallestWrite/nothing_written_first
    write_syncer_test.go:134:
        	Error:      	Not equal:
        	            	expected: 0
        	            	actual  : 3
        	Messages:   	Expected the smallest number of bytes written.
=== RUN   TestMultiWriteSyncerReturnsSmallestWrite/nothing_written_in_the_middle
    write_syncer_test.go:134:
        	Error:      	Not equal:
        	            	expected: 0
        	            	actual  : 5
--- FAIL: TestMultiWriteSyncerReturnsSmallestWrite (0.00s)
    --- PASS: .../ascending (0.00s)
    --- PASS: .../descending (0.00s)
    --- FAIL: .../nothing_written_first (0.00s)
    --- PASS: .../nothing_written_last (0.00s)
    --- FAIL: .../nothing_written_in_the_middle (0.00s)

After, all five pass, and so do the existing tests that pin the current
behaviour — TestMultiWriteSyncerFailsShortWrite,
TestMultiWriteSyncerWritesBoth, TestMultiWriteSyncerFailsWrite,
TestNewMultiWriteSyncerWorksForSingleWriter,
TestWritestoAllSyncs_EvenIfFirstErrors and the three
TestMultiWriteSyncerSync_* tests.

Benchmarks

Write is on the logging hot path when more than one output is configured, so
I benchmarked three no-op syncers writing 128 bytes, before and after,
interleaved over two rounds (-benchtime=1s -count=6, three fastest ns/op per
run):

round 1  after:  18.00 18.14 25.15      before: 22.79 23.95 35.31
round 2  after:  23.67 28.30 33.18      before: 13.33 17.51 18.28

The ordering flips between rounds, so there is no measurable difference on this
machine — as expected, since the change swaps two comparisons for one. Both
versions are 0 B/op, 0 allocs/op.

Verification

go vet ./...     # clean
gofmt -l zapcore # clean
go test ./...

go test ./... produces the same set of failures before and after: TestConfig,
TestConfigWithSamplingHook, TestOpen, TestOpenOtherErrors,
TestStacktraceFiltersVendorZap and zapcore.TestIOCore. All are pre-existing
and Windows-only on this machine (t.TempDir() cleanup cannot delete a file zap
still holds open; the stacktrace test needs symlink privileges) and fail
identically on an unmodified checkout.

🤖 Generated with Claude Code