feat: integrate flexible slog-based logging with dependency injection

- Add a new slog-based Logger implementation with support for text and JSON output formats
- Enable dependency injection of custom slog.Logger instances via an option
- Introduce flexible logger instantiation using option pattern (text, JSON, or custom)
- Provide tests for slog logger covering text mode, JSON mode, and custom logger injection

Signed-off-by: appleboy <appleboy.tw@gmail.com>

Author: appleboy

logger_test.go

@@ -2,11 +2,23 @@ package graceful
 
 import (
 	"bytes"
+	"context"
+	"log/slog"
 	"os"
 	"strings"
 	"testing"
 )
 
+// handlerFunc is a mock slog.Handler (test only)
+type handlerFunc struct {
+	fn func(r slog.Record) error
+}
+
+func (h handlerFunc) Handle(_ context.Context, r slog.Record) error { return h.fn(r) }
+func (h handlerFunc) Enabled(_ context.Context, _ slog.Level) bool  { return true }
+func (h handlerFunc) WithAttrs(_ []slog.Attr) slog.Handler          { return h }
+func (h handlerFunc) WithGroup(_ string) slog.Handler               { return h }
+
 func TestNewLogger_Infof_Errorf(t *testing.T) {
 	// Save original stdout and stderr
 	origStdout := os.Stdout
@@ -38,3 +50,76 @@ func TestNewLogger_Infof_Errorf(t *testing.T) {
 		t.Errorf("Errorf did not write expected message to stderr: %q", bufErr.String())
 	}
 }
+
+func TestNewSlogLogger_Text(t *testing.T) {
+	origStdout := os.Stdout
+	origStderr := os.Stderr
+	defer func() {
+		os.Stdout = origStdout
+		os.Stderr = origStderr
+	}()
+	rOut, wOut, _ := os.Pipe()
+	rErr, wErr, _ := os.Pipe()
+	os.Stdout = wOut
+	os.Stderr = wErr
+
+	logger := NewSlogLogger()
+	logger.Infof("info-text: %s", "foo")
+	logger.Errorf("error-text: %s", "bar")
+
+	wOut.Close()
+	wErr.Close()
+	var bufOut, bufErr bytes.Buffer
+	bufOut.ReadFrom(rOut)
+	bufErr.ReadFrom(rErr)
+
+	// Text handler should print plaintext, not JSON/bracketed
+	outStr := bufOut.String()
+	if !strings.Contains(outStr, "info-text: foo") {
+		t.Errorf("Text mode Infof missing: %q", outStr)
+	}
+}
+
+func TestNewSlogLogger_Json(t *testing.T) {
+	origStdout := os.Stdout
+	origStderr := os.Stderr
+	defer func() {
+		os.Stdout = origStdout
+		os.Stderr = origStderr
+	}()
+	rOut, wOut, _ := os.Pipe()
+	rErr, wErr, _ := os.Pipe()
+	os.Stdout = wOut
+	os.Stderr = wErr
+
+	logger := NewSlogLogger(WithJSON())
+	logger.Infof("info-json: %s", "foo")
+	logger.Errorf("error-json: %s", "bar")
+
+	wOut.Close()
+	wErr.Close()
+	var bufOut, bufErr bytes.Buffer
+	bufOut.ReadFrom(rOut)
+	bufErr.ReadFrom(rErr)
+
+	// JSON handler should output JSON encoded log
+	outStr := bufOut.String()
+	if !strings.Contains(outStr, "\"msg\":\"info-json: foo\"") {
+		t.Errorf("JSON mode Infof missing/invalid: %q", outStr)
+	}
+}
+
+func TestNewSlogLogger_WithSlog(t *testing.T) {
+	var captured []string
+	l := slog.New(handlerFunc{fn: func(r slog.Record) error {
+		var buf bytes.Buffer
+		buf.WriteString(r.Message)
+		captured = append(captured, buf.String())
+		return nil
+	}})
+	logger := NewSlogLogger(WithSlog(l))
+	logger.Infof("injected: %s", "foo")
+	if len(captured) != 1 || captured[0] != "injected: foo" {
+		t.Errorf("Custom slog.Logger was not used/injected properly, got %+v", captured)
+	}
+}

slog.go

@@ -0,0 +1,67 @@
+// Package graceful provides a Logger implementation using Go's log/slog.
+package graceful
+
+import (
+	"fmt"
+	"log/slog"
+	"os"
+)
+
+// slogLogger implements Logger interface using log/slog.
+type slogLogger struct {
+	logger *slog.Logger
+}
+
+// SlogLoggerOption applies configuration to NewSlogLogger.
+type SlogLoggerOption func(*slogLoggerOptions)
+
+type slogLoggerOptions struct {
+	logger *slog.Logger
+	json   bool
+}
+
+// WithJSON returns an option to set output as JSON format.
+func WithJSON() SlogLoggerOption {
+	return func(opt *slogLoggerOptions) { opt.json = true }
+}
+
+// WithSlog injects a custom *slog.Logger instance.
+func WithSlog(logger *slog.Logger) SlogLoggerOption {
+	return func(opt *slogLoggerOptions) { opt.logger = logger }
+}
+
+// NewSlogLogger creates a Logger using flexible option pattern.
+//
+// Usage:
+//
+//	NewSlogLogger()                        // text mode (default)
+//	NewSlogLogger(WithJson())              // json mode
+//	NewSlogLogger(WithSlog(loggerObj))     // inject custom *slog.Logger, which overrides other options
+func NewSlogLogger(opts ...SlogLoggerOption) Logger {
+	var o slogLoggerOptions
+	for _, f := range opts {
+		f(&o)
+	}
+	if o.logger != nil {
+		return &slogLogger{logger: o.logger}
+	}
+	var handler slog.Handler
+	if o.json {
+		handler = slog.NewJSONHandler(os.Stdout, nil)
+	} else {
+		handler = slog.NewTextHandler(os.Stdout, nil)
+	}
+	return &slogLogger{
+		logger: slog.New(handler),
+	}
+}
+
+func (l *slogLogger) Infof(format string, args ...interface{}) {
+	msg := fmt.Sprintf(format, args...)
+	l.logger.Info(msg)
+}
+
+func (l *slogLogger) Errorf(format string, args ...interface{}) {
+	msg := fmt.Sprintf(format, args...)
+	l.logger.Error(msg)
+}