From c929290c3c0e4e91337264d69e75ccb60522bc65 Mon Sep 17 00:00:00 2001
From: DmitriyLewen <91113035+DmitriyLewen@users.noreply.github.com>
Date: Mon, 2 Sep 2024 12:44:33 +0600
Subject: [PATCH] fix: logger initialization before flags parsing (#7372)

Signed-off-by: knqyf263 <knqyf263@gmail.com>
Co-authored-by: knqyf263 <knqyf263@gmail.com>
---
 pkg/log/deferred.go | 62 +++++++++++++++++++++++++++++++++++++++++++++
 pkg/log/logger.go   | 11 ++++++--
 2 files changed, 71 insertions(+), 2 deletions(-)
 create mode 100644 pkg/log/deferred.go

diff --git a/pkg/log/deferred.go b/pkg/log/deferred.go
new file mode 100644
index 000000000000..9fbf81652f4d
--- /dev/null
+++ b/pkg/log/deferred.go
@@ -0,0 +1,62 @@
+package log
+
+import (
+	"context"
+	"log/slog"
+	"slices"
+)
+
+func init() {
+	// Set the default logger so that logs are buffered until the logger is initialized.
+	slog.SetDefault(New(&DeferredHandler{records: new([]deferredRecord)}))
+}
+
+// DeferredHandler is needed to save logs and print them after calling `PrintLogs()` command.
+// For example, this may be necessary when the logger is not yet initialized, but messages need to be transmitted.
+// In this case, the messages are saved and printed when the logger is initialized.
+type DeferredHandler struct {
+	attrs []slog.Attr
+
+	// Shared with all instances of the handler.
+	// NOTE: non-thread safe
+	records *[]deferredRecord
+}
+
+type deferredRecord struct {
+	ctx context.Context
+	slog.Record
+}
+
+func (*DeferredHandler) Enabled(context.Context, slog.Level) bool {
+	return true
+}
+
+func (d *DeferredHandler) Handle(ctx context.Context, record slog.Record) error {
+	record.AddAttrs(d.attrs...)
+	*d.records = append(*d.records, deferredRecord{
+		ctx:    ctx,
+		Record: record,
+	})
+	return nil
+}
+
+func (d *DeferredHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	h := *d
+	h.attrs = slices.Clip(d.attrs)
+	h.attrs = append(h.attrs, attrs...)
+	return &h
+}
+
+func (*DeferredHandler) WithGroup(_ string) slog.Handler {
+	panic("WithGroup is not implemented")
+}
+
+func (d *DeferredHandler) Flush(h slog.Handler) {
+	for _, record := range *d.records {
+		if !h.Enabled(record.ctx, record.Level) {
+			continue
+		}
+		_ = h.Handle(record.ctx, record.Record)
+	}
+	d.records = nil
+}
diff --git a/pkg/log/logger.go b/pkg/log/logger.go
index 73c4231fd4af..ac629d211157 100644
--- a/pkg/log/logger.go
+++ b/pkg/log/logger.go
@@ -33,11 +33,18 @@ func New(h slog.Handler) *Logger {
 	return slog.New(h)
 }
 
-// InitLogger initialize the logger variable
+// InitLogger initializes the logger variable and flushes the buffered logs if needed.
 func InitLogger(debug, disable bool) {
 	level := lo.Ternary(debug, slog.LevelDebug, slog.LevelInfo)
 	out := lo.Ternary(disable, io.Discard, io.Writer(os.Stderr))
-	slog.SetDefault(New(NewHandler(out, &Options{Level: level})))
+	h := NewHandler(out, &Options{Level: level})
+
+	// Flush the buffered logs if needed.
+	if d, ok := slog.Default().Handler().(*DeferredHandler); ok {
+		d.Flush(h)
+	}
+
+	slog.SetDefault(New(h))
 }
 
 var (