Return sink write errors from every handler (closes #22)

The console and JSON handlers threw away the error from their write to
stdout, so a lost log line looked delivered. They now return it,
wrapped. The webhook handler also returns an error for a status outside
2xx, and no longer follows redirects, which could resend the request
without the record. The multiplex handler passes the record to every
handler and returns their errors joined with errors.Join instead of
stopping at the first.

Both stdout handlers gain an unexported writer, nil meaning os.Stdout at
write time, so tests can supply a sink that fails. The README says what
each handler returns and that the slog.Logger methods discard a
handler's error.

Model: opus-5-5

webhook_handler.go

@@ -4,16 +4,22 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"log/slog"
 	"net/http"
 	"net/url"
 )
 
+// errWebhookStatus is returned when the webhook answers with a status
+// outside 2xx.
+var errWebhookStatus = errors.New("webhook did not accept the record")
+
 // WebhookHandler POSTs each log record as JSON to a configured webhook
 // URL.
 type WebhookHandler struct {
 	webhookURL string
+	client     *http.Client
 	attrs      handlerAttrs
 }
 
@@ -25,7 +31,17 @@ func NewWebhookHandler(webhookURL string) (*WebhookHandler, error) {
 		return nil, fmt.Errorf("invalid webhook URL: %w", err)
 	}
 
-	return &WebhookHandler{webhookURL: webhookURL}, nil
+	return &WebhookHandler{
+		webhookURL: webhookURL,
+		client: &http.Client{
+			// Following a redirect can resend the request as a GET
+			// without the record, so Handle gets the redirect answer
+			// itself and returns it as an error.
+			CheckRedirect: func(*http.Request, []*http.Request) error {
+				return http.ErrUseLastResponse
+			},
+		},
+	}, nil
 }
 
 // Enabled reports whether the handler processes records at the given
@@ -43,6 +59,7 @@ func (w *WebhookHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
 
 	return &WebhookHandler{
 		webhookURL: w.webhookURL,
+		client:     w.client,
 		attrs:      w.attrs.withAttrs(attrs),
 	}
 }
@@ -56,12 +73,14 @@ func (w *WebhookHandler) WithGroup(name string) slog.Handler {
 
 	return &WebhookHandler{
 		webhookURL: w.webhookURL,
+		client:     w.client,
 		attrs:      w.attrs.withGroup(name),
 	}
 }
 
 // Handle marshals the record, with its attributes, to one JSON object and
-// POSTs it to the webhook URL.
+// POSTs it to the webhook URL. It returns an error when the request fails
+// or the server answers with a status outside 2xx.
 func (w *WebhookHandler) Handle(ctx context.Context, record slog.Record) error {
 	jsonData, err := json.Marshal(recordToMap(record, w.attrs))
 	if err != nil {
@@ -80,12 +99,17 @@ func (w *WebhookHandler) Handle(ctx context.Context, record slog.Record) error {
 
 	request.Header.Set("Content-Type", "application/json")
 
-	response, err := http.DefaultClient.Do(request)
+	response, err := w.client.Do(request)
 	if err != nil {
 		return err
 	}
 
 	defer func() { _ = response.Body.Close() }()
 
+	if response.StatusCode < http.StatusOK ||
+		response.StatusCode >= http.StatusMultipleChoices {
+		return fmt.Errorf("%w: %s", errWebhookStatus, response.Status)
+	}
+
 	return nil
 }