Merge remote-tracking branch 'origin/logger' into logger

# Conflicts:
#	logger/logger.go
#	logger/logger_config.go
#	main.go

logger/email_writer.go

@@ -0,0 +1,8 @@
+package logger
+
+type EmailWriter struct {
+}
+
+func (w EmailWriter) Write(p []byte) (n int, err error) {
+	return 0, err
+}

logger/logger.go

@@ -1,9 +1,145 @@
 package logger
 
 import (
+	"context"
+	"fmt"
 	"log/slog"
+	"os"
+	"sync"
 )
 
-func NewLogger(c Config) *slog.Logger {
-	return slog.New(NewHandler(c))
+type CtxAttrKey struct{}
+
+var (
+	once      sync.Once
+	ctxAttrMu sync.RWMutex
+	logger    *Logger
+)
+
+type Logger struct {
+	config  Config
+	logFile *os.File
+
+	stdoutLogger *slog.Logger
+	fileLogger   *slog.Logger
+	emailLogger  *slog.Logger
+}
+
+func Init(c Config) error {
+	var err error
+
+	once.Do(func() {
+		logger = &Logger{config: c}
+
+		if c.stdoutLogEnabled {
+			logger.stdoutLogger = slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+				AddSource: c.stdoutLogAddSource,
+				Level:     c.stdoutLogLevel,
+			}))
+		}
+
+		if c.fileLogEnabled {
+			logger.logFile, err = os.OpenFile(c.fileLogFilepath, os.O_APPEND|os.O_RDWR|os.O_CREATE, 0644)
+			if err != nil {
+				return
+			}
+
+			logger.fileLogger = slog.New(slog.NewJSONHandler(logger.logFile, &slog.HandlerOptions{
+				AddSource: c.fileLogAddSource,
+				Level:     c.fileLogLevel,
+			}))
+		}
+
+		if c.emailLogEnabled {
+
+			ew := EmailWriter{}
+
+			logger.emailLogger = slog.New(slog.NewJSONHandler(ew, &slog.HandlerOptions{
+				AddSource: c.emailLogAddSource,
+				Level:     c.emailLogLevel,
+			}))
+		}
+	})
+
+	return err
+}
+
+func Default() *Logger {
+	if logger == nil {
+		panic("logger not initialised")
+	}
+
+	return logger
+}
+
+func ErrorKV(ctx context.Context, msg string, args ...any) {
+	log(ctx, slog.LevelError, msg, args...)
+}
+
+func WarnKV(ctx context.Context, msg string, args ...any) {
+	log(ctx, slog.LevelWarn, msg, args...)
+}
+
+func InfoKV(ctx context.Context, msg string, args ...any) {
+	log(ctx, slog.LevelInfo, msg, args...)
+}
+
+func DebugKV(ctx context.Context, msg string, args ...any) {
+	log(ctx, slog.LevelDebug, msg, args...)
+}
+
+func Errorf(ctx context.Context, format string, args ...any) {
+	log(ctx, slog.LevelError, fmt.Sprintf(format, args...))
+}
+
+func Warnf(ctx context.Context, format string, args ...any) {
+	log(ctx, slog.LevelWarn, fmt.Sprintf(format, args...))
+}
+
+func Infof(ctx context.Context, format string, args ...any) {
+	log(ctx, slog.LevelInfo, fmt.Sprintf(format, args...))
+}
+
+func Debugf(ctx context.Context, format string, args ...any) {
+	log(ctx, slog.LevelDebug, fmt.Sprintf(format, args...))
+}
+
+func Error(ctx context.Context, msg string) {
+	log(ctx, slog.LevelError, msg)
+}
+
+func Warn(ctx context.Context, msg string) {
+	log(ctx, slog.LevelWarn, msg)
+}
+
+func Info(ctx context.Context, msg string) {
+	log(ctx, slog.LevelInfo, msg)
+}
+
+func Debug(ctx context.Context, msg string) {
+	log(ctx, slog.LevelDebug, msg)
+}
+
+func log(ctx context.Context, level slog.Level, msg string, args ...any) {
+	if Default().stdoutLogger != nil {
+		Default().stdoutLogger.Log(ctx, level, msg, append(args, AttrFromCtx(ctx)...)...)
+	}
+
+	if Default().fileLogger != nil {
+		Default().fileLogger.Log(ctx, level, msg, append(args, AttrFromCtx(ctx)...)...)
+	}
+
+	if Default().emailLogger != nil {
+		Default().emailLogger.Log(ctx, level, msg, append(args, AttrFromCtx(ctx)...)...)
+	}
+}
+
+func Close() error {
+	if Default().logFile != nil {
+		if err := Default().logFile.Close(); err != nil {
+			return err
+		}
+	}
+
+	return nil
 }

logger/logger_config.go

@@ -1,30 +1,23 @@
 package logger
 
-import (
-	"log/slog"
-	"time"
-)
-
-const (
-	defaultTimeFormat = time.DateTime
-)
+import "log/slog"
 
 type Config struct {
 	// stdout config
-	stdoutLogEnabled bool
-	stdoutLogLevel   slog.Level // INFO by default
+	stdoutLogEnabled   bool
+	stdoutLogLevel     slog.Level // INFO by default
+	stdoutLogAddSource bool
 
 	// file config
-	fileLogEnabled bool
-	fileLogLevel   slog.Level // INFO by default
+	fileLogEnabled   bool
+	fileLogLevel     slog.Level // INFO by default
+	fileLogAddSource bool
+	fileLogFilepath  string
 
 	// email config
-	emailLogEnabled bool
-	emailLogLevel   slog.Level // INFO by default
-
-	// common config
-	addSource  bool
-	timeFormat string
+	emailLogEnabled   bool
+	emailLogLevel     slog.Level // INFO by default
+	emailLogAddSource bool
 }
 
 type ConfigOption func(*Config)
@@ -44,50 +37,67 @@ func NewConfig(opts ...ConfigOption) Config {
 	return *c
 }
 
+// stdout log
+
 func WithStdoutLogEnabled(enabled bool) ConfigOption {
 	return func(s *Config) {
 		s.stdoutLogEnabled = enabled
 	}
 }
 
+func WithStdoutLogLevel(level slog.Level) ConfigOption {
+	return func(s *Config) {
+		s.stdoutLogLevel = level
+	}
+}
+func WithStdoutLogAddSource(add bool) ConfigOption {
+	return func(s *Config) {
+		s.stdoutLogAddSource = add
+	}
+}
+
+// file log
+
 func WithFileLogEnabled(enabled bool) ConfigOption {
 	return func(s *Config) {
 		s.fileLogEnabled = enabled
 	}
 }
 
-func WithEmailLogEnabled(enabled bool) ConfigOption {
+func WithFileLogLevel(level slog.Level) ConfigOption {
 	return func(s *Config) {
-		s.emailLogEnabled = enabled
+		s.fileLogLevel = level
 	}
 }
 
-func WithStdoutLogLevel(level slog.Level) ConfigOption {
+func WithFileLogAddSource(add bool) ConfigOption {
 	return func(s *Config) {
-		s.stdoutLogLevel = level
+		s.fileLogAddSource = add
 	}
 }
 
-func WithFileLogLevel(level slog.Level) ConfigOption {
+func WithFileLogFilepath(path string) ConfigOption {
 	return func(s *Config) {
-		s.fileLogLevel = level
+		s.fileLogFilepath = path
 	}
 }
 
-func WithEmailLogLevel(level slog.Level) ConfigOption {
+// email log
+
+func WithEmailLogEnabled(enabled bool) ConfigOption {
 	return func(s *Config) {
-		s.emailLogLevel = level
+		s.emailLogEnabled = enabled
 	}
 }
 
-func WithAddSource(add bool) ConfigOption {
+func WithEmailLogLevel(level slog.Level) ConfigOption {
 	return func(s *Config) {
-		s.addSource = add
+		s.emailLogLevel = level
 	}
 }
 
-func WithTimeFormat(format string) ConfigOption {
+func WithEmailLogAddSource(add bool) ConfigOption {
 	return func(s *Config) {
-		s.timeFormat = format
+		s.emailLogAddSource = add
 	}
 }

logger/logger_ctx.go

@@ -0,0 +1,28 @@
+package logger
+
+import "context"
+
+func With(ctx context.Context, key string, value any) context.Context {
+	ctxAttrMu.Lock()
+	defer ctxAttrMu.Unlock()
+
+	if ctx.Value(CtxAttrKey{}) == nil {
+		ctx = context.WithValue(ctx, CtxAttrKey{}, make([]any, 0))
+	}
+
+	kv, ok := ctx.Value(CtxAttrKey{}).([]any)
+	if !ok {
+		return ctx
+	}
+
+	return context.WithValue(ctx, CtxAttrKey{}, append(kv, key, value))
+}
+
+func AttrFromCtx(ctx context.Context) []any {
+	ctxAttrMu.RLock()
+	defer ctxAttrMu.RUnlock()
+
+	kv, _ := ctx.Value(CtxAttrKey{}).([]any)
+
+	return kv
+}

main.go

@@ -1,15 +1,31 @@
 package main
 
-import "git.dmitriygnatenko.ru/dima/go-common/logger"
+import (
+	"context"
+	"log/slog"
+
+	"git.dmitriygnatenko.ru/dima/go-common/logger"
+)
 
 func main() {
 
-	l := logger.NewLogger(logger.NewConfig(
-		logger.WithEmailLogEnabled(true),
+	err := logger.Init(logger.NewConfig(
+		logger.WithStdoutLogAddSource(true),
 		logger.WithStdoutLogEnabled(true),
+		logger.WithFileLogLevel(slog.LevelError),
+		logger.WithEmailLogEnabled(true),
 		logger.WithFileLogEnabled(true),
+		logger.WithFileLogFilepath("test_log.txt"),
 	))
 
-	l.Info("dfgdgdsg", "dsfsd", 232423, "aerew2", "val333")
+	_ = err
+
+	ctx := context.Background()
+
+	ctx = logger.With(ctx, "test111", 74658743)
+
+	logger.InfoKV(ctx, "dfgdgdfgdssg", "dsfsd", "val333", "dfgdf", 11)
+
+	// logger.Error(ctx, "dsfdsf dsf dsfs")
 
 }