fix(internal/syncwriter): suppress benign "reader gone" write errors

Ignore io.ErrClosedPipe and syscall.EPIPE in Write, the same way Sync
already ignores EINVAL, ENOTTY, and EBADF. When a sink's reader has gone
away the entry is undeliverable and the error is not actionable, so
reporting it only adds shutdown-time noise. os.ErrClosed is left
reported on purpose, since it usually means a write to a writer we
closed ourselves and is worth surfacing.

Evidence of the benign case: in a real coder/coder CI run a passing
TestRetryWithInterval was marked unknown because a concurrent
"port-forward -v" test logged into a closed pipe during teardown.
https://github.com/coder/coder/actions/runs/26586696037/job/78334548165

Author: EhabY

internal/syncwriter/syncwriter.go

@@ -36,6 +36,12 @@ func (w *Writer) Write(name string, p []byte) {
 	defer w.mu.Unlock()
 	_, err := w.w.Write(p)
 	if err != nil {
+		// A closed destination is benign: the reader is gone, so the
+		// entry is undeliverable and not worth reporting.
+		// See https://github.com/coder/slog/issues/225
+		if errorsIsAny(err, io.ErrClosedPipe, syscall.EPIPE) {
+			return
+		}
 		w.errorf("%v: failed to write entry: %+v", name, err)
 	}
 }

internal/syncwriter/syncwriter_test.go

@@ -1,9 +1,11 @@
 package syncwriter
 
 import (
+	"fmt"
 	"io"
 	"os"
 	"strings"
+	"syscall"
 	"testing"
 
 	"cdr.dev/slog/v3/internal/assert"
@@ -75,6 +77,57 @@ func TestWriter_Sync(t *testing.T) {
 	})
 }
 
+// Benign "destination closed" errors must not be reported.
+func TestWriter_Write_suppressesClosedDestinationErrors(t *testing.T) {
+	t.Parallel()
+
+	benign := []error{
+		io.ErrClosedPipe,
+		syscall.EPIPE,
+		fmt.Errorf("wrapped: %w", io.ErrClosedPipe),
+	}
+
+	for _, target := range benign {
+		target := target
+		t.Run(fmt.Sprintf("%v", target), func(t *testing.T) {
+			t.Parallel()
+
+			errors := 0
+			w := New(syncWriter{
+				wf: func([]byte) (int, error) { return 0, target },
+				sf: func() error { return nil },
+			})
+			w.errorf = func(string, ...interface{}) { errors++ }
+
+			w.Write("sloghuman", []byte("entry"))
+			assert.Equal(t, "errors", 0, errors)
+		})
+	}
+}
+
+func TestWriter_Write_reportsOtherErrors(t *testing.T) {
+	t.Parallel()
+
+	// os.ErrClosed is not suppressed: it usually means a write to an
+	// already-closed writer, which is worth surfacing.
+	for _, target := range []error{io.EOF, os.ErrClosed} {
+		target := target
+		t.Run(fmt.Sprintf("%v", target), func(t *testing.T) {
+			t.Parallel()
+
+			errors := 0
+			w := New(syncWriter{
+				wf: func([]byte) (int, error) { return 0, target },
+				sf: func() error { return nil },
+			})
+			w.errorf = func(string, ...interface{}) { errors++ }
+
+			w.Write("sloghuman", []byte("entry"))
+			assert.Equal(t, "errors", 1, errors)
+		})
+	}
+}
+
 // The default handler must report through the os.Stderr variable, not the
 // builtin println that bypasses it. Reverting to println fails this test.
 //