Add logger pkg (#67)

* Add logger pkg

* minor change

* Tests

* minor changes

* More changes

* Refactor logger

* fixes

* Minor change

Author: lucaslopezf

cmd/demo-metrics/main.go

@@ -1,17 +1,16 @@
 package main
 
 import (
-	"github.com/zondax/golem/pkg/cli"
 	"github.com/zondax/golem/pkg/constants"
+	"github.com/zondax/golem/pkg/logger"
 	"github.com/zondax/golem/pkg/metrics"
 	"github.com/zondax/golem/pkg/runner"
 )
 
 func main() {
 	println("[Demo] Microservice example")
 
-	_, _ = cli.InitGlobalLogger(constants.DebugLevel)
-
+	logger.InitLogger(logger.Config{Level: constants.DebugLevel})
 	r := runner.NewRunner()
 
 	r.AddTask(metrics.NewTaskMetrics("/metrics", "9090"))

cmd/demo-panic/main.go

@@ -1,17 +1,16 @@
 package main
 
 import (
-	"github.com/zondax/golem/pkg/cli"
 	"github.com/zondax/golem/pkg/constants"
+	"github.com/zondax/golem/pkg/logger"
 	"github.com/zondax/golem/pkg/metrics"
 	"github.com/zondax/golem/pkg/runner"
 )
 
 func main() {
 	println("[Demo] Panic handler")
 
-	_, _ = cli.InitGlobalLogger(constants.DebugLevel)
-
+	logger.InitLogger(logger.Config{Level: constants.DebugLevel})
 	r := runner.NewRunner()
 
 	// This will panic

pkg/cli/config.go

@@ -1,20 +1,21 @@
 package cli
 
 import (
+	"context"
 	"fmt"
+	"github.com/zondax/golem/pkg/logger"
 	"strings"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"go.uber.org/zap"
 )
 
 func SetupConfiguration(c *cobra.Command) {
 	var configFileFlag string
 	c.PersistentFlags().StringVarP(&configFileFlag, "config", "c", "", "The path to the config file to use.")
 	err := viper.BindPFlag("config", c.PersistentFlags().Lookup("config"))
 	if err != nil {
-		zap.S().Fatalf("unable to bind config flag: %+v", err)
+		logger.GetLoggerFromContext(context.Background()).Fatalf("unable to bind config flag: %+v", err)
 	}
 
 	viper.SetConfigName("config") // config file name without extension
@@ -49,12 +50,12 @@ func LoadConfig[T Config]() (*T, error) {
 	configFileOverride := viper.GetString("config")
 	if configFileOverride != "" {
 		viper.SetConfigFile(configFileOverride)
-		zap.S().Infof("Using config file: %s", viper.ConfigFileUsed())
+		logger.GetLoggerFromContext(context.Background()).Infof("Using config file: %s", viper.ConfigFileUsed())
 	}
 
 	err = viper.ReadInConfig()
 	if err != nil {
-		zap.S().Fatalf("%+v", err)
+		logger.GetLoggerFromContext(context.Background()).Fatalf("%+v", err)
 	}
 
 	// adds all default+configFile values in viper to struct

pkg/cli/handlers.go

@@ -1,7 +1,8 @@
 package cli
 
 import (
-	"go.uber.org/zap"
+	"context"
+	"github.com/zondax/golem/pkg/logger"
 	"os"
 	"os/signal"
 	"syscall"
@@ -14,13 +15,13 @@ func setupCloseHandler(handler CleanUpHandler) {
 	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
 	go func() {
 		<-c
-		zap.S().Warn("\r- Ctrl+C pressed in Terminal")
+		logger.GetLoggerFromContext(context.Background()).Warn("\r- Ctrl+C pressed in Terminal")
 
 		if handler != nil {
 			handler()
 		}
 
-		_ = zap.S().Sync() // Sync logger
+		_ = logger.Sync() // Sync logger
 		// TODO: friendly closing callback
 		os.Exit(0)
 	}()

pkg/cli/logging.go

@@ -5,7 +5,7 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/zondax/golem/pkg/constants"
-	"go.uber.org/zap"
+	"github.com/zondax/golem/pkg/logger"
 	"os"
 )
 
@@ -69,8 +69,7 @@ func (c *CLI) init() {
 	c.GetRoot().AddCommand(versionCmd)
 
 	// TODO: We can make this optional? and more configurable if we see the need
-	// Initialize logger
-	_, _ = InitGlobalLogger(constants.DebugLevel)
+	logger.InitLogger(logger.Config{Level: constants.DebugLevel})
 	setupCloseHandler(nil)
 	// Set Configuration Defaults
 	setupDefaultConfiguration(func() {
@@ -96,11 +95,11 @@ func (c *CLI) Run() {
 		if err != nil {
 			return
 		}
-		_ = zap.S().Sync()
+		_ = logger.Sync()
 		os.Exit(1)
 	}
 }
 
 func (c *CLI) Close() {
-	_ = zap.S().Sync()
+	_ = logger.Sync()
 }

pkg/cli/root.go

@@ -0,0 +1,119 @@
+package logger
+
+import (
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"strings"
+	"sync"
+)
+
+const (
+	ConsoleEncode        = "console"
+	initializingLogError = "initializing logger error: "
+)
+
+var (
+	defaultConfig = Config{
+		Level: "info",
+	}
+	baseLogger *zap.Logger
+	lock       sync.RWMutex
+)
+
+type Config struct {
+	Level    string `json:"level"`
+	Encoding string `json:"encoding"`
+}
+
+type Field struct {
+	Key   string
+	Value interface{}
+}
+
+type Logger struct {
+	logger *zap.Logger
+}
+
+var stringToLevel = map[string]zapcore.Level{
+	"debug": zapcore.DebugLevel,
+	"info":  zapcore.InfoLevel,
+	"warn":  zapcore.WarnLevel,
+	"error": zapcore.ErrorLevel,
+	"fatal": zapcore.FatalLevel,
+	"panic": zapcore.PanicLevel,
+}
+
+func InitLogger(config Config) {
+	lock.Lock()
+	defer lock.Unlock()
+
+	baseLogger = configureAndBuildLogger(config)
+	zap.ReplaceGlobals(baseLogger)
+}
+func NewLogger(opts ...interface{}) *Logger {
+	lock.Lock()
+	defer lock.Unlock()
+
+	var config Config
+	var fields []Field
+
+	for _, opt := range opts {
+		switch opt := opt.(type) {
+		case Config:
+			config = opt
+		case Field:
+			fields = append(fields, opt)
+		}
+	}
+
+	if config == (Config{}) {
+		config = DefaultConfig()
+	}
+
+	logger := configureAndBuildLogger(config).With(toZapFields(fields)...)
+	return &Logger{logger: logger}
+}
+
+func configureAndBuildLogger(config Config) *zap.Logger {
+	cfg := zap.NewProductionConfig()
+	if strings.EqualFold(config.Encoding, ConsoleEncode) {
+		cfg = zap.NewDevelopmentConfig()
+	}
+
+	encoderConfig := zap.NewProductionEncoderConfig()
+	encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
+	encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
+	cfg.EncoderConfig = encoderConfig
+
+	level := zapcore.InfoLevel
+	if l, ok := stringToLevel[strings.ToLower(config.Level)]; ok {
+		level = l
+	}
+	cfg.Level = zap.NewAtomicLevelAt(level)
+
+	logger, err := cfg.Build(zap.AddCallerSkip(1), zap.AddStacktrace(zapcore.ErrorLevel))
+	if err != nil {
+		panic(initializingLogError + err.Error())
+	}
+
+	return logger
+}
+
+func Sync() error {
+	lock.Lock()
+	defer lock.Unlock()
+
+	return baseLogger.Sync()
+}
+
+func DefaultConfig() Config {
+	return defaultConfig
+}
+
+func toZapFields(fields []Field) []zap.Field {
+	var zapFields []zap.Field
+	for _, field := range fields {
+		zapFields = append(zapFields, zap.Any(field.Key, field.Value))
+	}
+	return zapFields
+}

pkg/logger/logger.go

@@ -0,0 +1,83 @@
+package logger
+
+import (
+	"context"
+	"go.uber.org/zap"
+)
+
+const (
+	loggerKey    = "golem.logger"
+	RequestIDKey = "request_id"
+)
+
+func (l *Logger) Info(msg string) {
+	l.logger.Info(msg)
+}
+
+func (l *Logger) Debug(msg string) {
+	l.logger.Debug(msg)
+}
+
+func (l *Logger) Warn(msg string) {
+	l.logger.Warn(msg)
+}
+
+func (l *Logger) Error(msg string) {
+	l.logger.Error(msg)
+}
+
+func (l *Logger) DPanic(msg string) {
+	l.logger.DPanic(msg)
+}
+
+func (l *Logger) Panic(msg string) {
+	l.logger.Panic(msg)
+}
+
+func (l *Logger) Fatal(msg string) {
+	l.logger.Fatal(msg)
+}
+
+func (l *Logger) Infof(template string, args ...interface{}) {
+	l.logger.Sugar().Infof(template, args...)
+}
+
+func (l *Logger) Debugf(template string, args ...interface{}) {
+	l.logger.Sugar().Debugf(template, args...)
+}
+
+func (l *Logger) Warnf(template string, args ...interface{}) {
+	l.logger.Sugar().Warnf(template, args...)
+}
+
+func (l *Logger) Errorf(template string, args ...interface{}) {
+	l.logger.Sugar().Errorf(template, args...)
+}
+
+func (l *Logger) DPanicf(template string, args ...interface{}) {
+	l.logger.Sugar().DPanicf(template, args...)
+}
+
+func (l *Logger) Panicf(template string, args ...interface{}) {
+	l.logger.Sugar().Panicf(template, args...)
+}
+
+func (l *Logger) Fatalf(template string, args ...interface{}) {
+	l.logger.Sugar().Fatalf(template, args...)
+}
+
+func (l *Logger) WithFields(fields ...zap.Field) *Logger {
+	return &Logger{logger: l.logger.With(fields...)}
+}
+
+func GetLoggerFromContext(ctx context.Context) *Logger {
+	logger, ok := ctx.Value(loggerKey).(*Logger)
+	if !ok {
+		return NewLogger()
+	}
+	return logger
+}
+
+func ContextWithLogger(ctx context.Context, logger *Logger) context.Context {
+	return context.WithValue(ctx, loggerKey, logger) //nolint
+}