From a26f13701f9675da48620c89c28bccc44c9c6865 Mon Sep 17 00:00:00 2001 From: rjbasitali Date: Fri, 8 Apr 2022 16:50:46 +0500 Subject: [PATCH 1/8] 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, } } From 4897677857abc675db5020c84b6418aebeacc19c Mon Sep 17 00:00:00 2001 From: rjbasitali Date: Fri, 8 Apr 2022 16:55:02 +0500 Subject: [PATCH 2/8] unmarshal level fix --- logger_level.go | 14 +++++++------- my_logger.go | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/logger_level.go b/logger_level.go index 00ed547..c1e844e 100644 --- a/logger_level.go +++ b/logger_level.go @@ -44,19 +44,19 @@ func (l myLogger) Level(level uint8) Logger { func unmarshalLevel(level uint8) string { switch level { - case 1: + case alertFlag: return "alert" - case 2: + case errorFlag: return "error" - case 3: + case warnFlag: return "warn" - case 4: + case highlightFlag: return "highlight" - case 5: + case informFlag: return "inform" - case 6: + case logFlag: return "log" - case 7: + case traceFlag: return "trace" default: return "" diff --git a/my_logger.go b/my_logger.go index c39bd80..5fbbca4 100644 --- a/my_logger.go +++ b/my_logger.go @@ -28,7 +28,7 @@ func (l myLogger) log(level uint8, s ...interface{}) { if l.Writer == nil { return } - f := fmt.Sprintf("%s%s msg=%q\n", logPrefix(level), l.prefix, fmt.Sprint(s...)) + f := fmt.Sprintf("%s%s msg=%q", logPrefix(level), l.prefix, fmt.Sprint(s...)) fmt.Fprintln(l.Writer, f) } From c516a2cca006fed59601a69b489e63732102e837 Mon Sep 17 00:00:00 2001 From: rjbasitali Date: Mon, 11 Apr 2022 16:31:12 +0500 Subject: [PATCH 3/8] with fields --- fields.go | 6 ++++++ logger.go | 2 ++ my_logger.go | 24 +++++++++++++++++++++--- 3 files changed, 29 insertions(+), 3 deletions(-) create mode 100644 fields.go diff --git a/fields.go b/fields.go new file mode 100644 index 0000000..531e0c9 --- /dev/null +++ b/fields.go @@ -0,0 +1,6 @@ +package log + +func (l myLogger) WithFields(fields Fields) Logger { + l.data = fields + return l +} diff --git a/logger.go b/logger.go index 254be91..4f69469 100644 --- a/logger.go +++ b/logger.go @@ -29,4 +29,6 @@ type Logger interface { End(a ...interface{}) Level(uint8) Logger + + WithFields(fields Fields) Logger } diff --git a/my_logger.go b/my_logger.go index 5fbbca4..50b9ef1 100644 --- a/my_logger.go +++ b/my_logger.go @@ -13,22 +13,41 @@ var ( DefaultTimeFormat = time.RFC3339 ) +type Fields map[string]interface{} + type myLogger struct { Writer io.Writer prefix string begin time.Time level uint8 + data Fields } func logPrefix(level uint8) string { return fmt.Sprintf("time=%q level=%s function=%s", time.Now().Format(DefaultTimeFormat), unmarshalLevel(level), funcName()) } +func (fields Fields) String() string { + if len(fields) == 0 { + return "" + } + var buffer strings.Builder + for k, v := range fields { + switch v := v.(type) { + case string: + buffer.WriteString(fmt.Sprintf(" %s=%q", k, v)) + default: + buffer.WriteString(fmt.Sprintf(" %s=%v", k, v)) + } + } + return buffer.String() +} + func (l myLogger) log(level uint8, s ...interface{}) { if l.Writer == nil { return } - f := fmt.Sprintf("%s%s msg=%q", logPrefix(level), l.prefix, fmt.Sprint(s...)) + f := fmt.Sprintf("%s%s msg=%q %s", logPrefix(level), l.prefix, fmt.Sprint(s...), l.data) fmt.Fprintln(l.Writer, f) } @@ -36,9 +55,8 @@ func (l myLogger) logf(level uint8, format string, s ...interface{}) { if l.Writer == nil { return } - format = fmt.Sprintf("%%s %%s msg=\"%s\"\n", format) + format = fmt.Sprintf("%%s %%s msg=\"%s\" %s\n", format, l.data) s = append([]interface{}{logPrefix(level), l.prefix}, s...) - fmt.Fprintf(l.Writer, format, s...) } From 03389bcf756127eed6d6e15ac8df6d6e8827d575 Mon Sep 17 00:00:00 2001 From: rjbasitali Date: Mon, 11 Apr 2022 16:32:58 +0500 Subject: [PATCH 4/8] space trim --- my_logger.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/my_logger.go b/my_logger.go index 50b9ef1..cb721a2 100644 --- a/my_logger.go +++ b/my_logger.go @@ -55,7 +55,7 @@ func (l myLogger) logf(level uint8, format string, s ...interface{}) { if l.Writer == nil { return } - format = fmt.Sprintf("%%s %%s msg=\"%s\" %s\n", format, l.data) + format = fmt.Sprintf("%%s%%s msg=\"%s\" %s\n", format, l.data) s = append([]interface{}{logPrefix(level), l.prefix}, s...) fmt.Fprintf(l.Writer, format, s...) } From 483fe35623390759c88ceb97df6064a7c0d414ad Mon Sep 17 00:00:00 2001 From: rjbasitali Date: Mon, 11 Apr 2022 16:47:37 +0500 Subject: [PATCH 5/8] space trim fix --- my_logger.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/my_logger.go b/my_logger.go index cb721a2..9110b4a 100644 --- a/my_logger.go +++ b/my_logger.go @@ -47,7 +47,7 @@ func (l myLogger) log(level uint8, s ...interface{}) { if l.Writer == nil { return } - f := fmt.Sprintf("%s%s msg=%q %s", logPrefix(level), l.prefix, fmt.Sprint(s...), l.data) + f := fmt.Sprintf("%s%s msg=%q%s", logPrefix(level), l.prefix, fmt.Sprint(s...), l.data) fmt.Fprintln(l.Writer, f) } @@ -55,7 +55,7 @@ func (l myLogger) logf(level uint8, format string, s ...interface{}) { if l.Writer == nil { return } - format = fmt.Sprintf("%%s%%s msg=\"%s\" %s\n", format, l.data) + format = fmt.Sprintf("%%s%%s msg=\"%s\"%s\n", format, l.data) s = append([]interface{}{logPrefix(level), l.prefix}, s...) fmt.Fprintf(l.Writer, format, s...) } From b4c24b52c5cc6cec06a2acdd0eb146c09ff01a0e Mon Sep 17 00:00:00 2001 From: rjbasitali Date: Wed, 11 May 2022 15:52:05 +0500 Subject: [PATCH 6/8] err writer --- logger_begin.go | 2 +- logger_level.go | 2 +- logger_prefix.go | 2 +- my_logger.go | 63 +++++++++++++++++++++++++++++++++--------------- 4 files changed, 47 insertions(+), 22 deletions(-) diff --git a/logger_begin.go b/logger_begin.go index 9636439..95f22c1 100644 --- a/logger_begin.go +++ b/logger_begin.go @@ -6,6 +6,6 @@ func (l myLogger) Begin(s ...interface{}) Logger { if hasLevel(l.level, logFlag) { l.log(logFlag, append([]interface{}{"BEGIN"}, s...)...) } - logger := myLogger{Writer: l.Writer, prefix: l.prefix, begin: time.Now(), level: l.level} + logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: l.prefix, begin: time.Now(), level: l.level} return logger } diff --git a/logger_level.go b/logger_level.go index c1e844e..4474a13 100644 --- a/logger_level.go +++ b/logger_level.go @@ -20,7 +20,7 @@ const ( // Anything above 6 as level will be considered Level 6. // Pass 0 to output no logs. func (l myLogger) Level(level uint8) Logger { - logger := myLogger{Writer: l.Writer, prefix: l.prefix, begin: l.begin} + logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: l.prefix, begin: l.begin} switch level { case 1: logger.level = alertFlag diff --git a/logger_prefix.go b/logger_prefix.go index ef68ee7..e2d0426 100644 --- a/logger_prefix.go +++ b/logger_prefix.go @@ -11,6 +11,6 @@ func (l myLogger) Prefix(p ...string) Logger { for _, prefix := range p { buffer.WriteString(fmt.Sprintf("%s: ", prefix)) } - logger := myLogger{Writer: l.Writer, prefix: buffer.String()} + logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: buffer.String()} return logger } diff --git a/my_logger.go b/my_logger.go index 9110b4a..9fed251 100644 --- a/my_logger.go +++ b/my_logger.go @@ -16,11 +16,12 @@ var ( type Fields map[string]interface{} type myLogger struct { - Writer io.Writer - prefix string - begin time.Time - level uint8 - data Fields + Writer io.Writer + ErrWriter io.Writer + prefix string + begin time.Time + level uint8 + data Fields } func logPrefix(level uint8) string { @@ -43,21 +44,41 @@ func (fields Fields) String() string { return buffer.String() } -func (l myLogger) log(level uint8, s ...interface{}) { - if l.Writer == nil { - return +func (l myLogger) log(flag uint8, s ...interface{}) { + var w io.Writer + { + if flag != errorFlag && l.Writer == nil { + return + } else { + w = l.Writer + } + if flag == errorFlag && l.ErrWriter == nil { + return + } else { + w = l.ErrWriter + } } - f := fmt.Sprintf("%s%s msg=%q%s", logPrefix(level), l.prefix, fmt.Sprint(s...), l.data) - fmt.Fprintln(l.Writer, f) + f := fmt.Sprintf("%s%s msg=%q%s", logPrefix(flag), l.prefix, fmt.Sprint(s...), l.data) + fmt.Fprintln(w, f) } -func (l myLogger) logf(level uint8, format string, s ...interface{}) { - if l.Writer == nil { - return +func (l myLogger) logf(flag uint8, format string, s ...interface{}) { + var w io.Writer + { + if flag != errorFlag && l.Writer == nil { + return + } else { + w = l.Writer + } + if flag == errorFlag && l.ErrWriter == nil { + return + } else { + w = l.ErrWriter + } } format = fmt.Sprintf("%%s%%s msg=\"%s\"%s\n", format, l.data) - s = append([]interface{}{logPrefix(level), l.prefix}, s...) - fmt.Fprintf(l.Writer, format, s...) + s = append([]interface{}{logPrefix(flag), l.prefix}, s...) + fmt.Fprintf(w, format, s...) } func funcName() string { @@ -77,13 +98,17 @@ func funcName() string { return "" } -func NewLogger(w io.Writer) Logger { +func NewLogger(w, errw io.Writer) Logger { if w == nil { w = os.Stdout } + if errw == nil { + errw = os.Stderr + } return myLogger{ - Writer: w, - begin: time.Now(), - level: traceFlag, + Writer: w, + ErrWriter: errw, + begin: time.Now(), + level: traceFlag, } } From c4434fb40a232edb3b94d6398fe8daacbfb1cb82 Mon Sep 17 00:00:00 2001 From: rjbasitali Date: Fri, 20 May 2022 17:38:57 +0500 Subject: [PATCH 7/8] err writer fix --- my_logger.go | 18 ++++-------------- 1 file changed, 4 insertions(+), 14 deletions(-) diff --git a/my_logger.go b/my_logger.go index 9fed251..5f2eb06 100644 --- a/my_logger.go +++ b/my_logger.go @@ -47,16 +47,11 @@ func (fields Fields) String() string { func (l myLogger) log(flag uint8, s ...interface{}) { var w io.Writer { - if flag != errorFlag && l.Writer == nil { - return + if flag == errorFlag { + w = l.ErrWriter } else { w = l.Writer } - if flag == errorFlag && l.ErrWriter == nil { - return - } else { - w = l.ErrWriter - } } f := fmt.Sprintf("%s%s msg=%q%s", logPrefix(flag), l.prefix, fmt.Sprint(s...), l.data) fmt.Fprintln(w, f) @@ -65,16 +60,11 @@ func (l myLogger) log(flag uint8, s ...interface{}) { func (l myLogger) logf(flag uint8, format string, s ...interface{}) { var w io.Writer { - if flag != errorFlag && l.Writer == nil { - return + if flag == errorFlag { + w = l.ErrWriter } else { w = l.Writer } - if flag == errorFlag && l.ErrWriter == nil { - return - } else { - w = l.ErrWriter - } } format = fmt.Sprintf("%%s%%s msg=\"%s\"%s\n", format, l.data) s = append([]interface{}{logPrefix(flag), l.prefix}, s...) From 670b1f806b3e56fa0dbd2eddafeae68762903c8b Mon Sep 17 00:00:00 2001 From: rjbasitali Date: Mon, 23 May 2022 19:49:09 +0500 Subject: [PATCH 8/8] append fields --- fields.go | 8 +++++++- logger_begin.go | 2 +- logger_level.go | 2 +- logger_prefix.go | 2 +- 4 files changed, 10 insertions(+), 4 deletions(-) diff --git a/fields.go b/fields.go index 531e0c9..c0f2bdc 100644 --- a/fields.go +++ b/fields.go @@ -1,6 +1,12 @@ package log func (l myLogger) WithFields(fields Fields) Logger { - l.data = fields + if l.data != nil && len(l.data) > 0 { + for k, v := range fields { + l.data[k] = v + } + } else { + l.data = fields + } return l } diff --git a/logger_begin.go b/logger_begin.go index 95f22c1..b9e9c05 100644 --- a/logger_begin.go +++ b/logger_begin.go @@ -6,6 +6,6 @@ func (l myLogger) Begin(s ...interface{}) Logger { if hasLevel(l.level, logFlag) { l.log(logFlag, append([]interface{}{"BEGIN"}, s...)...) } - logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: l.prefix, begin: time.Now(), level: l.level} + logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: l.prefix, begin: time.Now(), level: l.level, data: l.data} return logger } diff --git a/logger_level.go b/logger_level.go index 4474a13..77a8e28 100644 --- a/logger_level.go +++ b/logger_level.go @@ -20,7 +20,7 @@ const ( // Anything above 6 as level will be considered Level 6. // Pass 0 to output no logs. func (l myLogger) Level(level uint8) Logger { - logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: l.prefix, begin: l.begin} + logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: l.prefix, begin: l.begin, data: l.data} switch level { case 1: logger.level = alertFlag diff --git a/logger_prefix.go b/logger_prefix.go index e2d0426..e61dcbd 100644 --- a/logger_prefix.go +++ b/logger_prefix.go @@ -11,6 +11,6 @@ func (l myLogger) Prefix(p ...string) Logger { for _, prefix := range p { buffer.WriteString(fmt.Sprintf("%s: ", prefix)) } - logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: buffer.String()} + logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: buffer.String(), data: l.data} return logger }