fix: logging module comments

This commit is contained in:
mayur.popli
2025-03-21 12:19:05 +05:30
parent 6ba266ad3a
commit 6547ffc370

View File

@@ -1,256 +1,256 @@
package log package log
import ( import (
"context" "context"
"errors" "errors"
"fmt" "fmt"
"io" "io"
"net/http" "net/http"
"os" "os"
"strconv" "strconv"
"sync" "sync"
"time" "time"
"github.com/rs/zerolog" "github.com/rs/zerolog"
"gopkg.in/natefinch/lumberjack.v2" "gopkg.in/natefinch/lumberjack.v2"
) )
type Level string type Level string
type DestinationType string type DestinationType string
type Destination struct { type Destination struct {
Type DestinationType `yaml:"type"` Type DestinationType `yaml:"type"`
Config map[string]string `yaml:"config"` Config map[string]string `yaml:"config"`
}
const (
Stdout DestinationType = "stdout"
File DestinationType = "file"
)
const (
DebugLevel Level = "debug"
InfoLevel Level = "info"
WarnLevel Level = "warn"
ErrorLevel Level = "error"
FatalLevel Level = "fatal"
PanicLevel Level = "panic"
)
var logLevels = map[Level]zerolog.Level{
DebugLevel: zerolog.DebugLevel,
InfoLevel: zerolog.InfoLevel,
WarnLevel: zerolog.WarnLevel,
ErrorLevel: zerolog.ErrorLevel,
FatalLevel: zerolog.FatalLevel,
PanicLevel: zerolog.PanicLevel,
}
type Config struct {
level Level `yaml:"level"`
destinations []Destination `yaml:"destinations"`
contextKeys []any `yaml:"contextKeys"`
}
var (
logger zerolog.Logger
cfg Config
once sync.Once
)
var (
ErrInvalidLogLevel = errors.New("invalid log level")
ErrLogDestinationNil = errors.New("log Destinations cant be empty")
ErrMissingFilePath = errors.New("file path missing in destination config for file logging")
)
func (config *Config) validate() error {
if _, exists := logLevels[config.level]; !exists {
return ErrInvalidLogLevel
} }
const ( if len(config.destinations) == 0 {
Stdout DestinationType = "stdout" return ErrLogDestinationNil
File DestinationType = "file"
)
const (
DebugLevel Level = "debug"
InfoLevel Level = "info"
WarnLevel Level = "warn"
ErrorLevel Level = "error"
FatalLevel Level = "fatal"
PanicLevel Level = "panic"
)
var logLevels = map[Level]zerolog.Level{
DebugLevel: zerolog.DebugLevel,
InfoLevel: zerolog.InfoLevel,
WarnLevel: zerolog.WarnLevel,
ErrorLevel: zerolog.ErrorLevel,
FatalLevel: zerolog.FatalLevel,
PanicLevel: zerolog.PanicLevel,
} }
type Config struct { for _, dest := range config.destinations {
level Level `yaml:"level"` switch dest.Type {
destinations []Destination `yaml:"destinations"` case Stdout:
contextKeys []any `yaml:"contextKeys"` case File:
} if _, exists := dest.Config["path"]; !exists {
return ErrMissingFilePath
}
var ( for _, key := range []string{"maxSize", "maxBackups", "maxAge"} {
logger zerolog.Logger if valStr, ok := dest.Config[key]; ok {
cfg Config if _, err := strconv.Atoi(valStr); err != nil {
once sync.Once return fmt.Errorf("invalid %s: %w", key, err)
)
var (
ErrInvalidLogLevel = errors.New("invalid log level")
ErrLogDestinationNil = errors.New("log Destinations cant be empty")
ErrMissingFilePath = errors.New("file path missing in destination config for file logging")
)
func (config *Config) validate() error {
if _, exists := logLevels[config.level]; !exists {
return ErrInvalidLogLevel
}
if len(config.destinations) == 0 {
return ErrLogDestinationNil
}
for _, dest := range config.destinations {
switch dest.Type {
case Stdout:
case File:
if _, exists := dest.Config["path"]; !exists {
return ErrMissingFilePath
}
for _, key := range []string{"maxSize", "maxBackups", "maxAge"} {
if valStr, ok := dest.Config[key]; ok {
if _, err := strconv.Atoi(valStr); err != nil {
return fmt.Errorf("invalid %s: %w", key, err)
}
} }
} }
default:
return fmt.Errorf("invalid destination type '%s'", dest.Type)
} }
default:
return fmt.Errorf("invalid destination type '%s'", dest.Type)
} }
return nil
} }
return nil
}
var defaultConfig = Config{ var defaultConfig = Config{
level: InfoLevel, level: InfoLevel,
destinations: []Destination{ destinations: []Destination{
{Type: Stdout}, {Type: Stdout},
}, },
contextKeys: []any{"userID", "requestID"}, contextKeys: []any{"userID", "requestID"},
} }
func init() { func init() {
logger, _ = getLogger(defaultConfig) logger, _ = getLogger(defaultConfig)
} }
func getLogger(config Config) (zerolog.Logger, error) { func getLogger(config Config) (zerolog.Logger, error) {
var newLogger zerolog.Logger var newLogger zerolog.Logger
var writers []io.Writer var writers []io.Writer
for _, dest := range config.destinations { for _, dest := range config.destinations {
switch dest.Type { switch dest.Type {
case Stdout: case Stdout:
writers = append(writers, os.Stdout) writers = append(writers, os.Stdout)
case File: case File:
filePath := dest.Config["path"] filePath := dest.Config["path"]
fmt.Printf("writing test log to file: %v\n", filePath) fmt.Printf("writing test log to file: %v\n", filePath)
lumberjackLogger := &lumberjack.Logger{ lumberjackLogger := &lumberjack.Logger{
Filename: filePath, Filename: filePath,
} }
setConfigValue := func(key string, target *int) { setConfigValue := func(key string, target *int) {
if valStr, ok := dest.Config[key]; ok { if valStr, ok := dest.Config[key]; ok {
if val, err := strconv.Atoi(valStr); err == nil { if val, err := strconv.Atoi(valStr); err == nil {
*target = val *target = val
}
} }
} }
setConfigValue("maxSize", &lumberjackLogger.MaxSize)
setConfigValue("maxBackups", &lumberjackLogger.MaxBackups)
setConfigValue("maxAge", &lumberjackLogger.MaxAge)
if compress, ok := dest.Config["compress"]; ok {
lumberjackLogger.Compress = compress == "true"
}
Info(context.Background(),"here")
writers = append(writers, lumberjackLogger)
} }
} setConfigValue("maxSize", &lumberjackLogger.MaxSize)
multiwriter := io.MultiWriter(writers...) setConfigValue("maxBackups", &lumberjackLogger.MaxBackups)
newLogger = zerolog.New(multiwriter). setConfigValue("maxAge", &lumberjackLogger.MaxAge)
Level(logLevels[config.level]). if compress, ok := dest.Config["compress"]; ok {
With(). lumberjackLogger.Compress = compress == "true"
Timestamp().
Caller().
Logger()
cfg = config
return newLogger, nil
}
func InitLogger(c Config) error {
if err := c.validate(); err != nil {
return err
}
var initErr error
once.Do(func() {
logger, initErr = getLogger(c)
})
return initErr
}
func Debug(ctx context.Context, msg string) {
logEvent(ctx, zerolog.DebugLevel, msg, nil)
}
func Debugf(ctx context.Context, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.DebugLevel, msg, nil)
}
func Info(ctx context.Context, msg string) {
logEvent(ctx, zerolog.InfoLevel, msg, nil)
}
func Infof(ctx context.Context, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.InfoLevel, msg, nil)
}
func Warn(ctx context.Context, msg string) {
logEvent(ctx, zerolog.WarnLevel, msg, nil)
}
func Warnf(ctx context.Context, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.WarnLevel, msg, nil)
}
func Error(ctx context.Context, err error, msg string) {
logEvent(ctx, zerolog.ErrorLevel, msg, err)
}
func Errorf(ctx context.Context, err error, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.ErrorLevel, msg, err)
}
func Fatal(ctx context.Context, err error, msg string) {
logEvent(ctx, zerolog.FatalLevel, msg, err)
}
func Fatalf(ctx context.Context, err error, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.FatalLevel, msg, err)
}
func Panic(ctx context.Context, err error, msg string) {
logEvent(ctx, zerolog.PanicLevel, msg, err)
}
func Panicf(ctx context.Context, err error, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.PanicLevel, msg, err)
}
func logEvent(ctx context.Context, level zerolog.Level, msg string, err error) {
event := logger.WithLevel(level)
if err != nil {
event = event.Err(err)
}
addCtx(ctx, event)
event.Msg(msg)
}
func Request(ctx context.Context, r *http.Request, body []byte) {
event := logger.Info()
addCtx(ctx, event)
event.Str("method", r.Method).
Str("url", r.URL.String()).
Str("body", string(body)).
Str("remoteAddr", r.RemoteAddr).
Msg("HTTP Request")
}
func addCtx(ctx context.Context, event *zerolog.Event) {
for _, key := range cfg.contextKeys {
val, ok := ctx.Value(key).(string)
if !ok {
continue
} }
keyStr := key.(string) Info(context.Background(), "here")
event.Str(keyStr, val) writers = append(writers, lumberjackLogger)
} }
} }
multiwriter := io.MultiWriter(writers...)
newLogger = zerolog.New(multiwriter).
Level(logLevels[config.level]).
With().
Timestamp().
Caller().
Logger()
func Response(ctx context.Context, r *http.Request, statusCode int, responseTime time.Duration) { cfg = config
event := logger.Info() return newLogger, nil
addCtx(ctx, event) }
event.Str("method", r.Method). func InitLogger(c Config) error {
Str("url", r.URL.String()).
Int("statusCode", statusCode). if err := c.validate(); err != nil {
Dur("responseTime", responseTime). return err
Msg("HTTP Response")
} }
var initErr error
once.Do(func() {
logger, initErr = getLogger(c)
})
return initErr
}
func Debug(ctx context.Context, msg string) {
logEvent(ctx, zerolog.DebugLevel, msg, nil)
}
func Debugf(ctx context.Context, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.DebugLevel, msg, nil)
}
func Info(ctx context.Context, msg string) {
logEvent(ctx, zerolog.InfoLevel, msg, nil)
}
func Infof(ctx context.Context, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.InfoLevel, msg, nil)
}
func Warn(ctx context.Context, msg string) {
logEvent(ctx, zerolog.WarnLevel, msg, nil)
}
func Warnf(ctx context.Context, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.WarnLevel, msg, nil)
}
func Error(ctx context.Context, err error, msg string) {
logEvent(ctx, zerolog.ErrorLevel, msg, err)
}
func Errorf(ctx context.Context, err error, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.ErrorLevel, msg, err)
}
func Fatal(ctx context.Context, err error, msg string) {
logEvent(ctx, zerolog.FatalLevel, msg, err)
}
func Fatalf(ctx context.Context, err error, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.FatalLevel, msg, err)
}
func Panic(ctx context.Context, err error, msg string) {
logEvent(ctx, zerolog.PanicLevel, msg, err)
}
func Panicf(ctx context.Context, err error, format string, v ...any) {
msg := fmt.Sprintf(format, v...)
logEvent(ctx, zerolog.PanicLevel, msg, err)
}
func logEvent(ctx context.Context, level zerolog.Level, msg string, err error) {
event := logger.WithLevel(level)
if err != nil {
event = event.Err(err)
}
addCtx(ctx, event)
event.Msg(msg)
}
func Request(ctx context.Context, r *http.Request, body []byte) {
event := logger.Info()
addCtx(ctx, event)
event.Str("method", r.Method).
Str("url", r.URL.String()).
Str("body", string(body)).
Str("remoteAddr", r.RemoteAddr).
Msg("HTTP Request")
}
func addCtx(ctx context.Context, event *zerolog.Event) {
for _, key := range cfg.contextKeys {
val, ok := ctx.Value(key).(string)
if !ok {
continue
}
keyStr := key.(string)
event.Str(keyStr, val)
}
}
func Response(ctx context.Context, r *http.Request, statusCode int, responseTime time.Duration) {
event := logger.Info()
addCtx(ctx, event)
event.Str("method", r.Method).
Str("url", r.URL.String()).
Int("statusCode", statusCode).
Dur("responseTime", responseTime).
Msg("HTTP Response")
}