log/slog: add multiple handlers support for logger

Fixes #65954

Change-Id: I88f880977782e632ed71699272e3e5d3985ea37b

Author: callthingsoff

api/next/65954.txt

@@ -0,0 +1 @@
+pkg log/slog, func MultiHandler(...Handler) Handler #65954

doc/next/6-stdlib/99-minor/log/slog/65954.md

@@ -0,0 +1,6 @@
+The [`MultiHandler`](/pkg/log/slog#MultiHandler) function returns a handler that
+invokes all the given Handlers.
+Its `Enable` method reports whether any of the handlers' `Enabled` methods
+return true.
+Its `Handle`, `WithAttr` and `WithGroup` methods call the corresponding method
+on each of the enabled handlers.

src/log/slog/handler.go

@@ -6,6 +6,7 @@ package slog
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"log/slog/internal/buffer"
@@ -642,3 +643,49 @@ func (dh discardHandler) Enabled(context.Context, Level) bool  { return false }
 func (dh discardHandler) Handle(context.Context, Record) error { return nil }
 func (dh discardHandler) WithAttrs(attrs []Attr) Handler       { return dh }
 func (dh discardHandler) WithGroup(name string) Handler        { return dh }
+
+// MultiHandler returns a handler that invokes all the given Handlers.
+// Its Enable method reports whether any of the handlers' Enabled methods return true.
+// Its Handle, WithAttr and WithGroup methods call the corresponding method on each of the enabled handlers.
+func MultiHandler(handlers ...Handler) Handler {
+	return multiHandler(handlers)
+}
+
+type multiHandler []Handler
+
+func (h multiHandler) Enabled(ctx context.Context, l Level) bool {
+	for i := range h {
+		if h[i].Enabled(ctx, l) {
+			return true
+		}
+	}
+	return false
+}
+
+func (h multiHandler) Handle(ctx context.Context, r Record) error {
+	var errs []error
+	for i := range h {
+		if h[i].Enabled(ctx, r.Level) {
+			if err := h[i].Handle(ctx, r.Clone()); err != nil {
+				errs = append(errs, err)
+			}
+		}
+	}
+	return errors.Join(errs...)
+}
+
+func (h multiHandler) WithAttrs(attrs []Attr) Handler {
+	handlers := make([]Handler, 0, len(h))
+	for i := range h {
+		handlers = append(handlers, h[i].WithAttrs(attrs))
+	}
+	return multiHandler(handlers)
+}
+
+func (h multiHandler) WithGroup(name string) Handler {
+	handlers := make([]Handler, 0, len(h))
+	for i := range h {
+		handlers = append(handlers, h[i].WithGroup(name))
+	}
+	return multiHandler(handlers)
+}

src/log/slog/multi_handler_test.go

@@ -0,0 +1,171 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package slog
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+)
+
+// mockFailingHandler is a handler that always returns an error from its Handle method.
+type mockFailingHandler struct {
+	Handler
+	err error
+}
+
+func (h *mockFailingHandler) Handle(ctx context.Context, r Record) error {
+	// It still calls the underlying handler's Handle method to ensure the log can be processed.
+	_ = h.Handler.Handle(ctx, r)
+	// But it always returns a predefined error.
+	return h.err
+}
+
+func TestMultiHandler(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("Handle sends log to all handlers", func(t *testing.T) {
+		var buf1, buf2 bytes.Buffer
+		h1 := NewTextHandler(&buf1, nil)
+		h2 := NewJSONHandler(&buf2, nil)
+
+		multi := MultiHandler(h1, h2)
+		logger := New(multi)
+
+		logger.Info("hello world", "user", "test")
+
+		// Check the output of the Text handler.
+		output1 := buf1.String()
+		if !strings.Contains(output1, `level=INFO`) ||
+			!strings.Contains(output1, `msg="hello world"`) ||
+			!strings.Contains(output1, `user=test`) {
+			t.Errorf("Text handler did not receive the correct log message. Got: %s", output1)
+		}
+
+		// Check the output of the JSON handle.
+		output2 := buf2.String()
+		if !strings.Contains(output2, `"level":"INFO"`) ||
+			!strings.Contains(output2, `"msg":"hello world"`) ||
+			!strings.Contains(output2, `"user":"test"`) {
+			t.Errorf("JSON handler did not receive the correct log message. Got: %s", output2)
+		}
+	})
+
+	t.Run("Enabled returns true if any handler is enabled", func(t *testing.T) {
+		h1 := NewTextHandler(&bytes.Buffer{}, &HandlerOptions{Level: LevelError})
+		h2 := NewTextHandler(&bytes.Buffer{}, &HandlerOptions{Level: LevelInfo})
+
+		multi := MultiHandler(h1, h2)
+
+		if !multi.Enabled(ctx, LevelInfo) {
+			t.Error("Enabled should be true for INFO level, but got false")
+		}
+		if !multi.Enabled(ctx, LevelError) {
+			t.Error("Enabled should be true for ERROR level, but got false")
+		}
+	})
+
+	t.Run("Enabled returns false if no handlers are enabled", func(t *testing.T) {
+		h1 := NewTextHandler(&bytes.Buffer{}, &HandlerOptions{Level: LevelError})
+		h2 := NewTextHandler(&bytes.Buffer{}, &HandlerOptions{Level: LevelInfo})
+
+		multi := MultiHandler(h1, h2)
+
+		if multi.Enabled(ctx, LevelDebug) {
+			t.Error("Enabled should be false for DEBUG level, but got true")
+		}
+	})
+
+	t.Run("WithAttrs propagates attributes to all handlers", func(t *testing.T) {
+		var buf1, buf2 bytes.Buffer
+		h1 := NewTextHandler(&buf1, nil)
+		h2 := NewJSONHandler(&buf2, nil)
+
+		multi := MultiHandler(h1, h2).WithAttrs([]Attr{String("request_id", "123")})
+		logger := New(multi)
+
+		logger.Info("request processed")
+
+		// Check if the Text handler contains the attribute.
+		if !strings.Contains(buf1.String(), "request_id=123") {
+			t.Errorf("Text handler output missing attribute. Got: %s", buf1.String())
+		}
+
+		// Check if the JSON handler contains the attribute.
+		if !strings.Contains(buf2.String(), `"request_id":"123"`) {
+			t.Errorf("JSON handler output missing attribute. Got: %s", buf2.String())
+		}
+	})
+
+	t.Run("WithGroup propagates group to all handlers", func(t *testing.T) {
+		var buf1, buf2 bytes.Buffer
+		h1 := NewTextHandler(&buf1, &HandlerOptions{AddSource: false})
+		h2 := NewJSONHandler(&buf2, &HandlerOptions{AddSource: false})
+
+		multi := MultiHandler(h1, h2).WithGroup("req")
+		logger := New(multi)
+
+		logger.Info("user login", "user_id", 42)
+
+		// Check if the Text handler contains the group.
+		expectedText := "req.user_id=42"
+		if !strings.Contains(buf1.String(), expectedText) {
+			t.Errorf("Text handler output missing group. Expected to contain %q, Got: %s", expectedText, buf1.String())
+		}
+
+		// Check if the JSON handler contains the group.
+		expectedJSON := `"req":{"user_id":42}`
+		if !strings.Contains(buf2.String(), expectedJSON) {
+			t.Errorf("JSON handler output missing group. Expected to contain %q, Got: %s", expectedJSON, buf2.String())
+		}
+	})
+
+	t.Run("Handle propagates errors from handlers", func(t *testing.T) {
+		var buf bytes.Buffer
+		h1 := NewTextHandler(&buf, nil)
+
+		// Simulate a handler that will fail.
+		errFail := errors.New("fake fail")
+		h2 := &mockFailingHandler{
+			Handler: NewTextHandler(&bytes.Buffer{}, nil),
+			err:     errFail,
+		}
+
+		multi := MultiHandler(h1, h2)
+
+		err := multi.Handle(ctx, NewRecord(time.Now(), LevelInfo, "test message", 0))
+
+		// Check if the error was returned correctly.
+		if err == nil {
+			t.Fatal("Expected an error from Handle, but got nil")
+		}
+		if !errors.Is(err, errFail) {
+			t.Errorf("Expected error: %v, but got: %v", errFail, err)
+		}
+
+		// Also, check that the successful handler still output the log.
+		if !strings.Contains(buf.String(), "test message") {
+			t.Error("The successful handler should still have processed the log")
+		}
+	})
+
+	t.Run("Handle with no handlers", func(t *testing.T) {
+		// Create an empty multi-handler.
+		multi := MultiHandler()
+		logger := New(multi)
+
+		// This should be safe to call and do nothing.
+		logger.Info("this is nothing")
+
+		// Calling Handle directly should also be safe.
+		err := multi.Handle(ctx, NewRecord(time.Now(), LevelInfo, "test", 0))
+		if err != nil {
+			t.Errorf("Handle with no sub-handlers should return nil, but got: %v", err)
+		}
+	})
+}