talent-plan-tinykv/log/log.go
Spade A be014c2aee
log: make log level case insensitive (#407)
Signed-off-by: SpadeA-Tang <u6748471@anu.edu.au>
2022-07-06 09:41:23 +00:00

283 lines
5.4 KiB
Go

// High level log wrapper, so it can output different log based on level.
//
// There are five levels in total: FATAL, ERROR, WARNING, INFO, DEBUG.
// The default log output level is INFO, you can change it by:
// - call log.SetLevel()
// - set environment variable `LOG_LEVEL`
package log
import (
"fmt"
"io"
"log"
"os"
"runtime"
"strings"
)
const (
Ldate = log.Ldate
Llongfile = log.Llongfile
Lmicroseconds = log.Lmicroseconds
Lshortfile = log.Lshortfile
LstdFlags = log.LstdFlags
Ltime = log.Ltime
)
type (
LogLevel int
LogType int
)
const (
LOG_FATAL = LogType(0x1)
LOG_ERROR = LogType(0x2)
LOG_WARNING = LogType(0x4)
LOG_INFO = LogType(0x8)
LOG_DEBUG = LogType(0x10)
)
const (
LOG_LEVEL_NONE = LogLevel(0x0)
LOG_LEVEL_FATAL = LOG_LEVEL_NONE | LogLevel(LOG_FATAL)
LOG_LEVEL_ERROR = LOG_LEVEL_FATAL | LogLevel(LOG_ERROR)
LOG_LEVEL_WARN = LOG_LEVEL_ERROR | LogLevel(LOG_WARNING)
LOG_LEVEL_INFO = LOG_LEVEL_WARN | LogLevel(LOG_INFO)
LOG_LEVEL_DEBUG = LOG_LEVEL_INFO | LogLevel(LOG_DEBUG)
LOG_LEVEL_ALL = LOG_LEVEL_DEBUG
)
const FORMAT_TIME_DAY string = "20060102"
const FORMAT_TIME_HOUR string = "2006010215"
var _log *Logger = New()
func init() {
SetFlags(Ldate | Ltime | Lshortfile)
SetHighlighting(runtime.GOOS != "windows")
}
func GlobalLogger() *log.Logger {
return _log._log
}
func SetLevel(level LogLevel) {
_log.SetLevel(level)
}
func GetLogLevel() LogLevel {
return _log.level
}
func SetFlags(flags int) {
_log._log.SetFlags(flags)
}
func Info(v ...interface{}) {
_log.Info(v...)
}
func Infof(format string, v ...interface{}) {
_log.Infof(format, v...)
}
func Panic(v ...interface{}) {
_log.Panic(v...)
}
func Panicf(format string, v ...interface{}) {
_log.Panicf(format, v...)
}
func Debug(v ...interface{}) {
_log.Debug(v...)
}
func Debugf(format string, v ...interface{}) {
_log.Debugf(format, v...)
}
func Warn(v ...interface{}) {
_log.Warning(v...)
}
func Warnf(format string, v ...interface{}) {
_log.Warningf(format, v...)
}
func Warning(v ...interface{}) {
_log.Warning(v...)
}
func Warningf(format string, v ...interface{}) {
_log.Warningf(format, v...)
}
func Error(v ...interface{}) {
_log.Error(v...)
}
func Errorf(format string, v ...interface{}) {
_log.Errorf(format, v...)
}
func Fatal(v ...interface{}) {
_log.Fatal(v...)
}
func Fatalf(format string, v ...interface{}) {
_log.Fatalf(format, v...)
}
func SetLevelByString(level string) {
_log.SetLevelByString(level)
}
func SetHighlighting(highlighting bool) {
_log.SetHighlighting(highlighting)
}
type Logger struct {
_log *log.Logger
level LogLevel
highlighting bool
}
func (l *Logger) SetHighlighting(highlighting bool) {
l.highlighting = highlighting
}
func (l *Logger) SetFlags(flags int) {
l._log.SetFlags(flags)
}
func (l *Logger) Flags() int {
return l._log.Flags()
}
func (l *Logger) SetLevel(level LogLevel) {
l.level = level
}
func (l *Logger) SetLevelByString(level string) {
l.level = StringToLogLevel(level)
}
func (l *Logger) log(t LogType, v ...interface{}) {
l.logf(t, "%v\n", v)
}
func (l *Logger) logf(t LogType, format string, v ...interface{}) {
if l.level|LogLevel(t) != l.level {
return
}
logStr, logColor := LogTypeToString(t)
var s string
if l.highlighting {
s = "\033" + logColor + "m[" + logStr + "] " + fmt.Sprintf(format, v...) + "\033[0m"
} else {
s = "[" + logStr + "] " + fmt.Sprintf(format, v...)
}
l._log.Output(4, s)
}
func (l *Logger) Fatal(v ...interface{}) {
l.log(LOG_FATAL, v...)
os.Exit(-1)
}
func (l *Logger) Fatalf(format string, v ...interface{}) {
l.logf(LOG_FATAL, format, v...)
os.Exit(-1)
}
func (l *Logger) Panic(v ...interface{}) {
l._log.Panic(v...)
}
func (l *Logger) Panicf(format string, v ...interface{}) {
l._log.Panicf(format, v...)
}
func (l *Logger) Error(v ...interface{}) {
l.log(LOG_ERROR, v...)
}
func (l *Logger) Errorf(format string, v ...interface{}) {
l.logf(LOG_ERROR, format, v...)
}
func (l *Logger) Warning(v ...interface{}) {
l.log(LOG_WARNING, v...)
}
func (l *Logger) Warningf(format string, v ...interface{}) {
l.logf(LOG_WARNING, format, v...)
}
func (l *Logger) Debug(v ...interface{}) {
l.log(LOG_DEBUG, v...)
}
func (l *Logger) Debugf(format string, v ...interface{}) {
l.logf(LOG_DEBUG, format, v...)
}
func (l *Logger) Info(v ...interface{}) {
l.log(LOG_INFO, v...)
}
func (l *Logger) Infof(format string, v ...interface{}) {
l.logf(LOG_INFO, format, v...)
}
func StringToLogLevel(level string) LogLevel {
level = strings.ToLower(level)
switch level {
case "fatal":
return LOG_LEVEL_FATAL
case "error":
return LOG_LEVEL_ERROR
case "warn":
return LOG_LEVEL_WARN
case "warning":
return LOG_LEVEL_WARN
case "debug":
return LOG_LEVEL_DEBUG
case "info":
return LOG_LEVEL_INFO
}
return LOG_LEVEL_ALL
}
func LogTypeToString(t LogType) (string, string) {
switch t {
case LOG_FATAL:
return "fatal", "[0;31"
case LOG_ERROR:
return "error", "[0;31"
case LOG_WARNING:
return "warning", "[0;33"
case LOG_DEBUG:
return "debug", "[0;36"
case LOG_INFO:
return "info", "[0;37"
}
return "unknown", "[0;37"
}
func New() *Logger {
return NewLogger(os.Stderr, "")
}
func NewLogger(w io.Writer, prefix string) *Logger {
var level LogLevel
if l := os.Getenv("LOG_LEVEL"); len(l) != 0 {
level = StringToLogLevel(os.Getenv("LOG_LEVEL"))
} else {
level = LOG_LEVEL_INFO
}
return &Logger{_log: log.New(w, prefix, LstdFlags), level: level, highlighting: true}
}