initial commit

logger/gost_logger.go

@@ -0,0 +1,155 @@
+package logger
+
+import (
+	"fmt"
+	"path/filepath"
+	"runtime"
+
+	"github.com/sirupsen/logrus"
+)
+
+var (
+	defaultLogger = NewLogger()
+)
+
+func Default() Logger {
+	return defaultLogger
+}
+
+func SetDefault(logger Logger) {
+	defaultLogger = logger
+}
+
+type logger struct {
+	logger *logrus.Entry
+}
+
+func NewLogger(opts ...LoggerOption) Logger {
+	var options LoggerOptions
+	for _, opt := range opts {
+		opt(&options)
+	}
+
+	log := logrus.New()
+	if options.Output != nil {
+		log.SetOutput(options.Output)
+	}
+
+	switch options.Format {
+	case TextFormat:
+		log.SetFormatter(&logrus.TextFormatter{
+			FullTimestamp: true,
+		})
+	default:
+		log.SetFormatter(&logrus.JSONFormatter{
+			DisableHTMLEscape: true,
+			// PrettyPrint:       true,
+		})
+	}
+
+	switch options.Level {
+	case DebugLevel, InfoLevel, WarnLevel, ErrorLevel, FatalLevel:
+		lvl, _ := logrus.ParseLevel(string(options.Level))
+		log.SetLevel(lvl)
+	default:
+		log.SetLevel(logrus.InfoLevel)
+	}
+
+	return &logger{
+		logger: logrus.NewEntry(log),
+	}
+}
+
+// WithFields adds new fields to log.
+func (l *logger) WithFields(fields map[string]any) Logger {
+	return &logger{
+		logger: l.logger.WithFields(logrus.Fields(fields)),
+	}
+}
+
+// Debug logs a message at level Debug.
+func (l *logger) Debug(args ...any) {
+	l.log(logrus.DebugLevel, args...)
+}
+
+// Debugf logs a message at level Debug.
+func (l *logger) Debugf(format string, args ...any) {
+	l.logf(logrus.DebugLevel, format, args...)
+}
+
+// Info logs a message at level Info.
+func (l *logger) Info(args ...any) {
+	l.log(logrus.InfoLevel, args...)
+}
+
+// Infof logs a message at level Info.
+func (l *logger) Infof(format string, args ...any) {
+	l.logf(logrus.InfoLevel, format, args...)
+}
+
+// Warn logs a message at level Warn.
+func (l *logger) Warn(args ...any) {
+	l.log(logrus.WarnLevel, args...)
+}
+
+// Warnf logs a message at level Warn.
+func (l *logger) Warnf(format string, args ...any) {
+	l.logf(logrus.WarnLevel, format, args...)
+}
+
+// Error logs a message at level Error.
+func (l *logger) Error(args ...any) {
+	l.log(logrus.ErrorLevel, args...)
+}
+
+// Errorf logs a message at level Error.
+func (l *logger) Errorf(format string, args ...any) {
+	l.logf(logrus.ErrorLevel, format, args...)
+}
+
+// Fatal logs a message at level Fatal then the process will exit with status set to 1.
+func (l *logger) Fatal(args ...any) {
+	l.log(logrus.FatalLevel, args...)
+	l.logger.Logger.Exit(1)
+}
+
+// Fatalf logs a message at level Fatal then the process will exit with status set to 1.
+func (l *logger) Fatalf(format string, args ...any) {
+	l.logf(logrus.FatalLevel, format, args...)
+	l.logger.Logger.Exit(1)
+}
+
+func (l *logger) GetLevel() LogLevel {
+	return LogLevel(l.logger.Logger.GetLevel().String())
+}
+
+func (l *logger) IsLevelEnabled(level LogLevel) bool {
+	lvl, _ := logrus.ParseLevel(string(level))
+	return l.logger.Logger.IsLevelEnabled(lvl)
+}
+
+func (l *logger) log(level logrus.Level, args ...any) {
+	lg := l.logger
+	if l.logger.Logger.IsLevelEnabled(logrus.DebugLevel) {
+		lg = lg.WithField("caller", l.caller(3))
+	}
+	lg.Log(level, args...)
+}
+
+func (l *logger) logf(level logrus.Level, format string, args ...any) {
+	lg := l.logger
+	if l.logger.Logger.IsLevelEnabled(logrus.DebugLevel) {
+		lg = lg.WithField("caller", l.caller(3))
+	}
+	lg.Logf(level, format, args...)
+}
+
+func (l *logger) caller(skip int) string {
+	_, file, line, ok := runtime.Caller(skip)
+	if !ok {
+		file = "<???>"
+	} else {
+		file = filepath.Join(filepath.Base(filepath.Dir(file)), filepath.Base(file))
+	}
+	return fmt.Sprintf("%s:%d", file, line)
+}

logger/logger.go

@@ -0,0 +1,71 @@
+package logger
+
+import (
+	"io"
+)
+
+// LogFormat is format type
+type LogFormat string
+
+const (
+	TextFormat LogFormat = "text"
+	JSONFormat LogFormat = "json"
+)
+
+// LogLevel is Logger Level type
+type LogLevel string
+
+const (
+	// DebugLevel has verbose message
+	DebugLevel LogLevel = "debug"
+	// InfoLevel is default log level
+	InfoLevel LogLevel = "info"
+	// WarnLevel is for logging messages about possible issues
+	WarnLevel LogLevel = "warn"
+	// ErrorLevel is for logging errors
+	ErrorLevel LogLevel = "error"
+	// FatalLevel is for logging fatal messages. The system shuts down after logging the message.
+	FatalLevel LogLevel = "fatal"
+)
+
+type Logger interface {
+	WithFields(map[string]any) Logger
+	Debug(args ...any)
+	Debugf(format string, args ...any)
+	Info(args ...any)
+	Infof(format string, args ...any)
+	Warn(args ...any)
+	Warnf(format string, args ...any)
+	Error(args ...any)
+	Errorf(format string, args ...any)
+	Fatal(args ...any)
+	Fatalf(format string, args ...any)
+	GetLevel() LogLevel
+	IsLevelEnabled(level LogLevel) bool
+}
+
+type LoggerOptions struct {
+	Output io.Writer
+	Format LogFormat
+	Level  LogLevel
+}
+
+type LoggerOption func(opts *LoggerOptions)
+
+func OutputLoggerOption(out io.Writer) LoggerOption {
+	return func(opts *LoggerOptions) {
+		opts.Output = out
+	}
+}
+
+func FormatLoggerOption(format LogFormat) LoggerOption {
+	return func(opts *LoggerOptions) {
+		opts.Format = format
+	}
+}
+
+func LevelLoggerOption(level LogLevel) LoggerOption {
+	return func(opts *LoggerOptions) {
+		opts.Level = level
+	}
+}

logger/nop_logger.go

@@ -0,0 +1,53 @@
+package logger
+
+var (
+	nop = &nopLogger{}
+)
+
+func Nop() Logger {
+	return nop
+}
+
+type nopLogger struct{}
+
+func (l *nopLogger) WithFields(fields map[string]any) Logger {
+	return l
+}
+
+func (l *nopLogger) Debug(args ...any) {
+}
+
+func (l *nopLogger) Debugf(format string, args ...any) {
+}
+
+func (l *nopLogger) Info(args ...any) {
+}
+
+func (l *nopLogger) Infof(format string, args ...any) {
+}
+
+func (l *nopLogger) Warn(args ...any) {
+}
+
+func (l *nopLogger) Warnf(format string, args ...any) {
+}
+
+func (l *nopLogger) Error(args ...any) {
+}
+
+func (l *nopLogger) Errorf(format string, args ...any) {
+}
+
+func (l *nopLogger) Fatal(args ...any) {
+}
+
+func (l *nopLogger) Fatalf(format string, args ...any) {
+}
+
+func (l *nopLogger) GetLevel() LogLevel {
+	return ""
+}
+
+func (l *nopLogger) IsLevelEnabled(level LogLevel) bool {
+	return false
+}