From a26f13701f9675da48620c89c28bccc44c9c6865 Mon Sep 17 00:00:00 2001 From: rjbasitali Date: Fri, 8 Apr 2022 16:50:46 +0500 Subject: [PATCH] logfmt formatted logs --- logger_alert.go | 4 ++-- logger_begin.go | 2 +- logger_end.go | 2 +- logger_error.go | 4 ++-- logger_highlight.go | 4 ++-- logger_inform.go | 4 ++-- logger_level.go | 45 ++++++++++++++++++++++++++++++++++----------- logger_log.go | 4 ++-- logger_trace.go | 4 ++-- logger_warn.go | 4 ++-- my_logger.go | 35 ++++++++++++++++++++++++----------- 11 files changed, 74 insertions(+), 38 deletions(-) diff --git a/logger_alert.go b/logger_alert.go index b6ed88a..2411a80 100644 --- a/logger_alert.go +++ b/logger_alert.go @@ -4,12 +4,12 @@ func (l myLogger) Alert(a ...interface{}) { if !hasLevel(l.level, alertFlag) { return } - l.log(a...) + l.log(alertFlag, a...) } func (l myLogger) Alertf(format string, a ...interface{}) { if !hasLevel(l.level, alertFlag) { return } - l.logf(format, a...) + l.logf(alertFlag, format, a...) } diff --git a/logger_begin.go b/logger_begin.go index 54eac56..9636439 100644 --- a/logger_begin.go +++ b/logger_begin.go @@ -4,7 +4,7 @@ import "time" func (l myLogger) Begin(s ...interface{}) Logger { if hasLevel(l.level, logFlag) { - l.log(append([]interface{}{"BEGIN"}, s...)...) + l.log(logFlag, append([]interface{}{"BEGIN"}, s...)...) } logger := myLogger{Writer: l.Writer, prefix: l.prefix, begin: time.Now(), level: l.level} return logger diff --git a/logger_end.go b/logger_end.go index e5c8e5a..ddaa46d 100644 --- a/logger_end.go +++ b/logger_end.go @@ -8,6 +8,6 @@ import ( func (l myLogger) End(s ...interface{}) { if hasLevel(l.level, logFlag) { var p []interface{} = append([]interface{}{fmt.Sprintf("END δt=%dµs", time.Now().Sub(l.begin)/1000)}, s...) - l.log(p...) + l.log(logFlag, p...) } } diff --git a/logger_error.go b/logger_error.go index 58c1bf6..60aed6d 100644 --- a/logger_error.go +++ b/logger_error.go @@ -4,12 +4,12 @@ func (l myLogger) Error(a ...interface{}) { if !hasLevel(l.level, errorFlag) { return } - l.log(a...) + l.log(errorFlag, a...) } func (l myLogger) Errorf(format string, a ...interface{}) { if !hasLevel(l.level, errorFlag) { return } - l.logf(format, a...) + l.logf(errorFlag, format, a...) } diff --git a/logger_highlight.go b/logger_highlight.go index b8f5a24..50f2bcd 100644 --- a/logger_highlight.go +++ b/logger_highlight.go @@ -4,12 +4,12 @@ func (l myLogger) Highlight(a ...interface{}) { if !hasLevel(l.level, highlightFlag) { return } - l.log(a...) + l.log(highlightFlag, a...) } func (l myLogger) Highlightf(format string, a ...interface{}) { if !hasLevel(l.level, highlightFlag) { return } - l.logf(format, a...) + l.logf(highlightFlag, format, a...) } diff --git a/logger_inform.go b/logger_inform.go index 1549423..4da3ad5 100644 --- a/logger_inform.go +++ b/logger_inform.go @@ -4,12 +4,12 @@ func (l myLogger) Inform(a ...interface{}) { if !hasLevel(l.level, informFlag) { return } - l.log(a...) + l.log(informFlag, a...) } func (l myLogger) Informf(format string, a ...interface{}) { if !hasLevel(l.level, informFlag) { return } - l.logf(format, a...) + l.logf(informFlag, format, a...) } diff --git a/logger_level.go b/logger_level.go index bc23077..00ed547 100644 --- a/logger_level.go +++ b/logger_level.go @@ -2,12 +2,12 @@ package log const ( alertFlag = 0b00000001 // L1 - errorFlag = 0b00000001 // L1 - warnFlag = 0b00000010 // L2 - highlightFlag = 0b00000100 // L3 - informFlag = 0b00001000 // L4 - logFlag = 0b00010000 // L5 - traceFlag = 0b00100000 // L6 + errorFlag = 0b00000010 // L2 + warnFlag = 0b00000100 // L3 + highlightFlag = 0b00001000 // L4 + informFlag = 0b00010000 // L5 + logFlag = 0b00100000 // L6 + traceFlag = 0b01000000 // L7 ) // Level returns a leveled logger, level can be from 1 to 6. @@ -23,16 +23,18 @@ func (l myLogger) Level(level uint8) Logger { logger := myLogger{Writer: l.Writer, prefix: l.prefix, begin: l.begin} switch level { case 1: - logger.level = alertFlag | errorFlag + logger.level = alertFlag case 2: - logger.level = alertFlag | errorFlag | warnFlag + logger.level = alertFlag | errorFlag case 3: - logger.level = alertFlag | errorFlag | warnFlag | highlightFlag + logger.level = alertFlag | errorFlag | warnFlag case 4: - logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag + logger.level = alertFlag | errorFlag | warnFlag | highlightFlag case 5: - logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag | logFlag + logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag case 6: + logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag | logFlag + case 7: logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag | logFlag | traceFlag default: logger.level = 0 @@ -40,6 +42,27 @@ func (l myLogger) Level(level uint8) Logger { return logger } +func unmarshalLevel(level uint8) string { + switch level { + case 1: + return "alert" + case 2: + return "error" + case 3: + return "warn" + case 4: + return "highlight" + case 5: + return "inform" + case 6: + return "log" + case 7: + return "trace" + default: + return "" + } +} + func hasLevel(b uint8, flag uint8) bool { return b&flag != 0 } diff --git a/logger_log.go b/logger_log.go index 3794cdb..999a58f 100644 --- a/logger_log.go +++ b/logger_log.go @@ -4,12 +4,12 @@ func (l myLogger) Log(s ...interface{}) { if !hasLevel(l.level, logFlag) { return } - l.log(s...) + l.log(logFlag, s...) } func (l myLogger) Logf(format string, s ...interface{}) { if !hasLevel(l.level, logFlag) { return } - l.logf(format, s...) + l.logf(logFlag, format, s...) } diff --git a/logger_trace.go b/logger_trace.go index c401599..e57aada 100644 --- a/logger_trace.go +++ b/logger_trace.go @@ -4,12 +4,12 @@ func (l myLogger) Trace(a ...interface{}) { if !hasLevel(l.level, traceFlag) { return } - l.log(a...) + l.log(traceFlag, a...) } func (l myLogger) Tracef(format string, a ...interface{}) { if !hasLevel(l.level, traceFlag) { return } - l.logf(format, a...) + l.logf(traceFlag, format, a...) } diff --git a/logger_warn.go b/logger_warn.go index db8b110..e060320 100644 --- a/logger_warn.go +++ b/logger_warn.go @@ -4,12 +4,12 @@ func (l myLogger) Warn(a ...interface{}) { if !hasLevel(l.level, warnFlag) { return } - l.log(a...) + l.log(warnFlag, a...) } func (l myLogger) Warnf(format string, a ...interface{}) { if !hasLevel(l.level, warnFlag) { return } - l.logf(format, a...) + l.logf(warnFlag, format, a...) } diff --git a/my_logger.go b/my_logger.go index 112f0a0..c39bd80 100644 --- a/my_logger.go +++ b/my_logger.go @@ -9,6 +9,10 @@ import ( "time" ) +var ( + DefaultTimeFormat = time.RFC3339 +) + type myLogger struct { Writer io.Writer prefix string @@ -16,20 +20,24 @@ type myLogger struct { level uint8 } -func (l myLogger) log(s ...interface{}) { - if l.Writer == nil { - return - } - s = append([]interface{}{l.prefix, funcName()}, s...) - fmt.Fprintln(l.Writer, s...) +func logPrefix(level uint8) string { + return fmt.Sprintf("time=%q level=%s function=%s", time.Now().Format(DefaultTimeFormat), unmarshalLevel(level), funcName()) } -func (l myLogger) logf(format string, s ...interface{}) { +func (l myLogger) log(level uint8, s ...interface{}) { if l.Writer == nil { return } - format = fmt.Sprintf("%%s %%s %s\n", format) - s = append([]interface{}{l.prefix, funcName()}, s...) + f := fmt.Sprintf("%s%s msg=%q\n", logPrefix(level), l.prefix, fmt.Sprint(s...)) + fmt.Fprintln(l.Writer, f) +} + +func (l myLogger) logf(level uint8, format string, s ...interface{}) { + if l.Writer == nil { + return + } + format = fmt.Sprintf("%%s %%s msg=\"%s\"\n", format) + s = append([]interface{}{logPrefix(level), l.prefix}, s...) fmt.Fprintf(l.Writer, format, s...) } @@ -40,7 +48,12 @@ func funcName() string { for _, p := range pc { fn := runtime.FuncForPC(p) if !strings.HasPrefix(fn.Name(), "github.com/rjbasitali/go-log") { - return fn.Name() + fname := fn.Name() + i := strings.LastIndexByte(fname, byte('/')) + if i == -1 { + return fname + } + return fname[i+1:] } } return "" @@ -53,6 +66,6 @@ func NewLogger(w io.Writer) Logger { return myLogger{ Writer: w, begin: time.Now(), - level: 63, + level: traceFlag, } }