log/slog: add multiple handlers support for logger

[lxl-renren]

Proposal Details

Currently slog package a logger only support one handler.
For most language like python, A log module should be sent to multiple targets for output simultaneously for a logger. This feature is necessary， I propose adding multiple handlers support for logger.
cc @golang/proposal-review

[seankhliao]

it's unclear why this needs to be in the standard library when it can accomplished as a handler. as the first example I found: https://github.com/samber/slog-multi

[lxl-renren]

I agree other third-party library like "slog-multi" accomplished this functionality. Although third-party solutions exist, standardizing this functionality offers several benefits:

• Consistency and Ease of Use: A standardized approach ensures consistent behavior and API across different projects using the slog package. This reduces the learning curve and simplifies adoption for new users.
• Discoverability and Integration: Integrating with a standard library feature is often easier. Users don't need to search for and manage dependencies on external packages, making development and maintenance smoother.
• Quality and Maintenance: Standard library features are actively maintained by the Go team, receiving regular updates, bug fixes, and security patches. This ensures a reliable and well-supported solution for users.

Using third-party library like "slog-multi" may not be maintained consistently, potentially leading to compatibility issues in the future.

[ianlancetaylor]

CC @jba

[jba]

@lxl-renren While I agree with you about the values of standardization, I don't think this particular feature warrants it. It is easy enough to write and not needed often enough to justify the added maintenance burden to the Go team.

However, that is just my opinion, and we can and should let the proposal process take its course.

[fishjam]

I want this feature too.
As I know, lots of project will save logs to multi target , example:

• local file's log with more detail(level is debug);
• remote elk log with less detail ( example: level is info )
• and maybe alarm email log ( example: level is error )

current slog can not support such case.

[alireza-fa]

If we need to log in two different outputs, we can use io.Multiwriter
logger = slog.New(
slog.NewJSONHandler(io.MultiWriter(fileWriter, os.Stdout), &slog.HandlerOptions{}),
)
If we need to log in two different output with different values, example:

• local file's log with more detail(level is debug);
• remote elk log with less detail ( example: level is info )
• and maybe alarm email log ( example: level is error )

we can warp slog in a custom Logger and handling this sutiations.

[featuriz]

io.Multiwriter works. But it fixed logLevel for all.
@alireza-fa can you please provide some code to start with

[jba]

@featuriz here is a sketch of the code:

The MultiHandler would be a struct that holds a slice of Handlers.

Its Enabled method would return true if any of the contained handlers' Enabled methods returns true.

Its Handle method would re-check the Enabled method of each contained handler, and if true, it would call Handle on that handler.

The WithGroup and WithAttrs methods would call those methods on every contained handler, replacing each handler with the method's return value.

[ianthehat]

Its Handle method would re-check the Enabled method of each contained handler, and if true, it would call Handle on that handler.

I am not sure it needs to do this, the point of Enabled was just an optimization to avoid building the message, by the time you call the multi Handle that optimization no longer applies and I don't think there is any guarantee in the system that Handle does not get called just because Enabled is false, so it should just unconditionally deliver the message to all the handlers and let them reject ones they did not want.

I have written this code a couple of times for bifurcation, not bothered to generalize it to N handlers though.

[alireza-fa]

---

Yes, I will definitely provide you with a practical example:

package logger

import (
	"io"
	"log/slog"
	"os"

	"gopkg.in/natefinch/lumberjack.v2"
)

const (
	defaultFilePath        = "logs/logs.json"
	defaultUserLocalTime   = false
	defaultFileMaxSizeInMB = 10
	defaultFileAgeInDays   = 30
	defaultLogLevel        = slog.LevelInfo
)

type Config struct {
	FilePath         string `koanf:"file_path"`
	UseLocalTime     bool   `koanf:"use_local_time"`
	FileMaxSizeInMB  int    `koanf:"file_max_size_in_mb"`
	FileMaxAgeInDays int    `koanf:"file_max_age_in_days"`
	LogLevel         int    `koanf:"log_level"`
}

var l *slog.Logger

func init() {
	fileWriter := &lumberjack.Logger{
		Filename:  defaultFilePath,
		LocalTime: defaultUserLocalTime,
		MaxSize:   defaultFileMaxSizeInMB,
		MaxAge:    defaultFileAgeInDays,
	}
	l = slog.New(slog.NewJSONHandler(io.MultiWriter(fileWriter, os.Stdout), &slog.HandlerOptions{
		Level: defaultLogLevel,
	}))
}

func L() *slog.Logger {
	return l
}

func New(cfg Config, opt *slog.HandlerOptions, writeInConsole bool) *slog.Logger {
	fileWriter := &lumberjack.Logger{
		Filename:  cfg.FilePath,
		LocalTime: cfg.UseLocalTime,
		MaxSize:   cfg.FileMaxSizeInMB,
		MaxAge:    cfg.FileMaxAgeInDays,
	}

	if writeInConsole {
		return slog.New(slog.NewJSONHandler(io.MultiWriter(fileWriter, os.Stdout), opt))
	}

	return slog.New(slog.NewJSONHandler(fileWriter, opt))
}

In this example, we specified that the logs should be displayed in the console as well as written to the specified file.

---

@featuriz