logger

logx/log.go

@@ -0,0 +1,115 @@
+package logx
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Fields type, used to pass to `WithFields`.
+type Fields map[string]any
+
+type Level uint32
+
+// Convert the Level to a string. E.g. PanicLevel becomes "panic".
+func (level Level) String() string {
+	if b, err := level.MarshalText(); err == nil {
+		return string(b)
+	} else {
+		return "unknown"
+	}
+}
+
+// ParseLevel takes a string level and returns the Logrus log level constant.
+func ParseLevel(lvl string) (Level, error) {
+	switch strings.ToLower(lvl) {
+	case "panic":
+		return PanicLevel, nil
+	case "fatal":
+		return FatalLevel, nil
+	case "error":
+		return ErrorLevel, nil
+	case "warn", "warning":
+		return WarnLevel, nil
+	case "info":
+		return InfoLevel, nil
+	case "debug":
+		return DebugLevel, nil
+	case "trace":
+		return TraceLevel, nil
+	}
+
+	var l Level
+	return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+func (level *Level) UnmarshalText(text []byte) error {
+	l, err := ParseLevel(string(text))
+	if err != nil {
+		return err
+	}
+
+	*level = l
+
+	return nil
+}
+
+func (level Level) MarshalText() ([]byte, error) {
+	switch level {
+	case TraceLevel:
+		return []byte("trace"), nil
+	case DebugLevel:
+		return []byte("debug"), nil
+	case InfoLevel:
+		return []byte("info"), nil
+	case WarnLevel:
+		return []byte("warning"), nil
+	case ErrorLevel:
+		return []byte("error"), nil
+	case FatalLevel:
+		return []byte("fatal"), nil
+	case PanicLevel:
+		return []byte("panic"), nil
+	}
+
+	return nil, fmt.Errorf("not a valid logrus level %d", level)
+}
+
+// These are the different logging levels. You can set the logging level to log
+// on your instance of logger, obtained with `logrus.New()`.
+const (
+	// PanicLevel level, highest level of severity. Logs and then calls panic with the
+	// message passed to Debug, Info, ...
+	PanicLevel Level = iota
+	// FatalLevel level. Logs and then calls `logger.Exit(1)`. It will exit even if the
+	// logging level is set to Panic.
+	FatalLevel
+	// ErrorLevel level. Logs. Used for errors that should definitely be noted.
+	// Commonly used for hooks to send errors to an error tracking service.
+	ErrorLevel
+	// WarnLevel level. Non-critical entries that deserve eyes.
+	WarnLevel
+	// InfoLevel level. General operational entries about what's going on inside the
+	// application.
+	InfoLevel
+	// DebugLevel level. Usually only enabled when debugging. Very verbose logging.
+	DebugLevel
+	// TraceLevel level. Designates finer-grained informational events than the Debug.
+	TraceLevel
+)
+
+type Logger interface {
+	SetLevel(level Level)
+	WithField(key string, value any) Logger
+	WithFields(fields Fields) Logger
+	Info(args ...any)
+	Infof(format string, args ...any)
+	Warn(args ...any)
+	Error(args ...any)
+	Warnf(format string, args ...any)
+	Errorf(format string, args ...any)
+	Fatalf(format string, args ...any)
+	Println(args ...any)
+	Print(args ...any)
+	Printf(format string, args ...any)
+}

logx/logrus.go

@@ -0,0 +1,69 @@
+package logx
+
+import "github.com/sirupsen/logrus"
+
+type logrusWrpper struct {
+	logger *logrus.Entry
+}
+
+func CreateLogrus() Logger {
+	logger := logrus.New()
+
+	return &logrusWrpper{
+		logger: logrus.NewEntry(logger),
+	}
+}
+
+func (l *logrusWrpper) SetLevel(level Level) {
+	l.logger.Logger.SetLevel(logrus.Level(level))
+}
+
+func (l *logrusWrpper) WithField(key string, value any) Logger {
+	return l.WithFields(Fields{key: value})
+}
+
+func (l *logrusWrpper) WithFields(fields Fields) Logger {
+	return &logrusWrpper{
+		logger: l.logger.WithFields(logrus.Fields(fields)),
+	}
+}
+
+func (l *logrusWrpper) Info(args ...any) {
+	l.logger.Info(args...)
+}
+
+func (l *logrusWrpper) Infof(format string, args ...any) {
+	l.logger.Infof(format, args...)
+}
+
+func (l *logrusWrpper) Warn(args ...any) {
+	l.logger.Warn(args...)
+}
+
+func (l *logrusWrpper) Error(args ...any) {
+	l.Error(args...)
+}
+
+func (l *logrusWrpper) Warnf(format string, args ...any) {
+	l.Warnf(format, args...)
+}
+
+func (l *logrusWrpper) Errorf(format string, args ...any) {
+	l.Errorf(format, args...)
+}
+
+func (l *logrusWrpper) Fatalf(format string, args ...any) {
+	l.Fatalf(format, args...)
+}
+
+func (entry *logrusWrpper) Println(args ...interface{}) {
+	entry.logger.Infoln(args...)
+}
+
+func (entry *logrusWrpper) Print(args ...interface{}) {
+	entry.Info(args...)
+}
+
+func (entry *logrusWrpper) Printf(format string, args ...interface{}) {
+	entry.Infof(format, args...)
+}