proposal: remove logger pkg

[alexanderbez]

We have a logger package that contains an abstraction over Go's standard slog logger. I do not see a benefit in having an interface/abstraction over slog for the following reasons:

1. slog (as of Go 1.26) can support multiple writers on a single logger (being released this month Feb)
2. We have no foreseeable interest in ever supporting a different logger other than slog
3. The DX in the interface is actually a bit clunky, i.e. I'd prefer and argue it's cleaner and simpler to read logger.Error("...", "err", err, "val", 4) instead of logger.Error("...", err, logger.With*(...)). In other words, just provide the variadic fields; logger.With*(...) is not necessary and just makes the code verbose.

cc @hpsing @abergasov

[linear]

OPT-367

[Walentalien]

Since slog can support multiple writer we should maybe review if we need that module in common at all @abergasov @alexanderbez

[alexanderbez]

https://go.dev/doc/go1.26#logslogpkglogslog

[Walentalien]

https://optimum-o8x7557.slack.com/archives/C08LRQ8KDNC/p1771929951408939?thread_ts=1771929685.755449&cid=C08LRQ8KDNC

[Walentalien]

Mb we pick that up for next cycle

[abergasov]

multiple writer is just a helper that we do not need implement by ourself, latest go release did it for us

we need this logger because of reasons that i wrote in this comments
we just deprecate interface because there is no reason, since there are only one implementation of this interface

[alexanderbez]

Correct. Just remove the interface @Walentalien.

[alexanderbez]

Just an update here. I really don't see us needing much here beyond a single helper

var levels = map[string]slog.Level{
	"debug": slog.LevelDebug,
	"info":  slog.LevelInfo,
	"warn":  slog.LevelWarn,
	"error": slog.LevelError,
}

// New creates a new logger with the given level and format. If the provided
// level is invalid, it defaults to info.
func New(level, format string, writers []io.Writer, attrs ...slog.Attr) *slog.Logger {
	sLevel := slog.LevelInfo
	if l, ok := levels[strings.ToLower(level)]; ok {
		sLevel = l
	}

	replaceAttrs := func(_ []string, a slog.Attr) slog.Attr {
		switch a.Key {
		case "time":
			return slog.Int64("timestamp", a.Value.Time().Unix())

		case "gray_log_level":
			return slog.Int64("level", a.Value.Int64())
		}

		return a
	}

	handlers := make([]slog.Handler, len(writers))
	for i, w := range writers {
		var handler slog.Handler
		if strings.EqualFold(format, config.LogFormatJSON) {
			handler = slog.NewJSONHandler(w, &slog.HandlerOptions{
				Level:       sLevel,
				ReplaceAttr: replaceAttrs,
			})
		} else {
			handler = tint.NewHandler(w, &tint.Options{
				Level:      sLevel,
				TimeFormat: time.Kitchen,
			})
		}

		handlers[i] = handler
	}

	args := make([]any, 0, len(attrs)+2)
	for _, attr := range attrs {
		args = append(args, attr)
	}

	args = append(args, slog.String("commit", version.GetCommitHash()))
	args = append(args, slog.String("version", version.GetVersion()))

	return slog.New(slog.NewMultiHandler(handlers...)).With(args...)
}