From d1c3291281cd6da1655c00f8673e0480c46340c7 Mon Sep 17 00:00:00 2001 From: xm1k3 Date: Tue, 3 Jan 2023 14:31:22 +0100 Subject: [PATCH 1/5] added SetTimestamp() --- gologger.go | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/gologger.go b/gologger.go index dc2b762..6753bbe 100644 --- a/gologger.go +++ b/gologger.go @@ -22,6 +22,7 @@ var ( } // DefaultLogger is the default logging instance DefaultLogger *Logger + addTimestamp bool ) func init() { @@ -94,6 +95,12 @@ func (e *Event) TimeStamp() *Event { return e } +// SetTimestamp sets a global flag indicating whether or not to add timestamps to debug logs. +// If the flag is set to true, timestamps will be added to debug logs. +func SetTimestamp(timestamp bool) { + addTimestamp = timestamp +} + // Str adds a string metadata item to the log func (e *Event) Str(key, value string) *Event { e.metadata[key] = value @@ -167,6 +174,11 @@ func Debug() *Event { metadata: make(map[string]string), } event.metadata["label"] = labels[level] + + if addTimestamp { + event.TimeStamp() + } + return event } From 7255efd50018c2a503818eae14ce8163def09569 Mon Sep 17 00:00:00 2001 From: xm1k3 Date: Tue, 3 Jan 2023 21:46:13 +0100 Subject: [PATCH 2/5] declare addTimestamp as Logger field --- gologger.go | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/gologger.go b/gologger.go index 6753bbe..e4bca03 100644 --- a/gologger.go +++ b/gologger.go @@ -22,7 +22,6 @@ var ( } // DefaultLogger is the default logging instance DefaultLogger *Logger - addTimestamp bool ) func init() { @@ -34,9 +33,10 @@ func init() { // Logger is a logger for logging structured data in a beautfiul and fast manner. type Logger struct { - writer writer.Writer - maxLevel levels.Level - formatter formatter.Formatter + writer writer.Writer + maxLevel levels.Level + formatter formatter.Formatter + addTimestamp bool } // Log logs a message to a logger instance @@ -75,6 +75,12 @@ func (l *Logger) SetWriter(writer writer.Writer) { l.writer = writer } +// SetTimestamp sets a global flag indicating whether or not to add timestamps to debug logs. +// If the flag is set to true, timestamps will be added to debug logs. +func SetTimestamp(timestamp bool) { + DefaultLogger.addTimestamp = timestamp +} + // Event is a log event to be written with data type Event struct { logger *Logger @@ -95,12 +101,6 @@ func (e *Event) TimeStamp() *Event { return e } -// SetTimestamp sets a global flag indicating whether or not to add timestamps to debug logs. -// If the flag is set to true, timestamps will be added to debug logs. -func SetTimestamp(timestamp bool) { - addTimestamp = timestamp -} - // Str adds a string metadata item to the log func (e *Event) Str(key, value string) *Event { e.metadata[key] = value @@ -175,7 +175,7 @@ func Debug() *Event { } event.metadata["label"] = labels[level] - if addTimestamp { + if DefaultLogger.addTimestamp { event.TimeStamp() } From 4730dc898df425440754c49ad28e1eb0c8af4601 Mon Sep 17 00:00:00 2001 From: xm1k3 Date: Tue, 3 Jan 2023 21:52:46 +0100 Subject: [PATCH 3/5] moved SetTimeout under Logger --- gologger.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/gologger.go b/gologger.go index e4bca03..dd62b20 100644 --- a/gologger.go +++ b/gologger.go @@ -75,12 +75,6 @@ func (l *Logger) SetWriter(writer writer.Writer) { l.writer = writer } -// SetTimestamp sets a global flag indicating whether or not to add timestamps to debug logs. -// If the flag is set to true, timestamps will be added to debug logs. -func SetTimestamp(timestamp bool) { - DefaultLogger.addTimestamp = timestamp -} - // Event is a log event to be written with data type Event struct { logger *Logger @@ -311,6 +305,12 @@ func (l *Logger) Verbose() *Event { return event } +// SetTimestamp sets a global flag indicating whether or not to add timestamps to debug logs. +// If the flag is set to true, timestamps will be added to debug logs. +func (l *Logger) SetTimestamp(timestamp bool) { + DefaultLogger.addTimestamp = timestamp +} + func isCurrentLevelEnabled(e *Event) bool { return e.level <= e.logger.maxLevel } From 88bae4d70647f75b7a307838b79960072ceb94fc Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Wed, 4 Jan 2023 08:51:56 +0100 Subject: [PATCH 4/5] general refactor --- gologger.go | 176 ++++++++++++++++++---------------------------------- 1 file changed, 59 insertions(+), 117 deletions(-) diff --git a/gologger.go b/gologger.go index dd62b20..5aab171 100644 --- a/gologger.go +++ b/gologger.go @@ -33,10 +33,11 @@ func init() { // Logger is a logger for logging structured data in a beautfiul and fast manner. type Logger struct { - writer writer.Writer - maxLevel levels.Level - formatter formatter.Formatter - addTimestamp bool + writer writer.Writer + maxLevel levels.Level + formatter formatter.Formatter + timestampMinLevel levels.Level + timestamp bool } // Log logs a message to a logger instance @@ -75,6 +76,12 @@ func (l *Logger) SetWriter(writer writer.Writer) { l.writer = writer } +// SetTimestamp enables/disables automatic timestamp +func (l *Logger) SetTimestamp(timestamp bool, minLevel levels.Level) { + l.timestamp = timestamp + l.timestampMinLevel = minLevel +} + // Event is a log event to be written with data type Event struct { logger *Logger @@ -83,6 +90,26 @@ type Event struct { metadata map[string]string } +func newDefaultEventWithLevel(level levels.Level) *Event { + return newEventWithLevelAndLogger(level, DefaultLogger) +} + +func newEventWithLevelAndLogger(level levels.Level, l *Logger) *Event { + event := &Event{ + logger: l, + level: level, + metadata: make(map[string]string), + } + if l.timestamp && level >= l.timestampMinLevel { + event.TimeStamp() + } + return event +} + +func (e *Event) setLevelMetadata(level levels.Level) { + e.metadata["label"] = labels[level] +} + // Label applies a custom label on the log event func (e *Event) Label(label string) *Event { e.metadata["label"] = label @@ -125,192 +152,107 @@ func (e *Event) MsgFunc(messageSupplier func() string) { // Info writes a info message on the screen with the default label func Info() *Event { - level := levels.LevelInfo - event := &Event{ - logger: DefaultLogger, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newDefaultEventWithLevel(levels.LevelInfo) + event.setLevelMetadata(levels.LevelInfo) return event } // Warning writes a warning message on the screen with the default label func Warning() *Event { - level := levels.LevelWarning - event := &Event{ - logger: DefaultLogger, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newDefaultEventWithLevel(levels.LevelWarning) + event.setLevelMetadata(levels.LevelWarning) return event } // Error writes a error message on the screen with the default label func Error() *Event { - level := levels.LevelError - event := &Event{ - logger: DefaultLogger, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newDefaultEventWithLevel(levels.LevelError) + event.setLevelMetadata(levels.LevelError) return event } // Debug writes an error message on the screen with the default label func Debug() *Event { - level := levels.LevelDebug - event := &Event{ - logger: DefaultLogger, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] - - if DefaultLogger.addTimestamp { - event.TimeStamp() - } - + event := newDefaultEventWithLevel(levels.LevelDebug) + event.setLevelMetadata(levels.LevelDebug) return event } // Fatal exits the program if we encounter a fatal error func Fatal() *Event { - level := levels.LevelFatal - event := &Event{ - logger: DefaultLogger, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newDefaultEventWithLevel(levels.LevelFatal) + event.setLevelMetadata(levels.LevelFatal) return event } // Silent prints a string on stdout without any extra labels. func Silent() *Event { - level := levels.LevelSilent - event := &Event{ - logger: DefaultLogger, - level: level, - metadata: make(map[string]string), - } + event := newDefaultEventWithLevel(levels.LevelSilent) + event.setLevelMetadata(levels.LevelSilent) return event } // Print prints a string on stderr without any extra labels. func Print() *Event { - level := levels.LevelInfo - event := &Event{ - logger: DefaultLogger, - level: level, - metadata: make(map[string]string), - } + event := newDefaultEventWithLevel(levels.LevelInfo) return event } // Verbose prints a string only in verbose output mode. func Verbose() *Event { - level := levels.LevelVerbose - event := &Event{ - logger: DefaultLogger, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newDefaultEventWithLevel(levels.LevelVerbose) + event.setLevelMetadata(levels.LevelVerbose) return event } // Info writes a info message on the screen with the default label func (l *Logger) Info() *Event { - level := levels.LevelInfo - event := &Event{ - logger: l, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newEventWithLevelAndLogger(levels.LevelInfo, l) + event.setLevelMetadata(levels.LevelInfo) return event } // Warning writes a warning message on the screen with the default label func (l *Logger) Warning() *Event { - level := levels.LevelWarning - event := &Event{ - logger: l, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newEventWithLevelAndLogger(levels.LevelWarning, l) + event.setLevelMetadata(levels.LevelWarning) return event } // Error writes a error message on the screen with the default label func (l *Logger) Error() *Event { - level := levels.LevelError - event := &Event{ - logger: l, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newEventWithLevelAndLogger(levels.LevelError, l) + event.setLevelMetadata(levels.LevelError) return event } // Debug writes an error message on the screen with the default label func (l *Logger) Debug() *Event { - level := levels.LevelDebug - event := &Event{ - logger: l, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newEventWithLevelAndLogger(levels.LevelDebug, l) + event.setLevelMetadata(levels.LevelDebug) return event } // Fatal exits the program if we encounter a fatal error func (l *Logger) Fatal() *Event { - level := levels.LevelFatal - event := &Event{ - logger: l, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newEventWithLevelAndLogger(levels.LevelFatal, l) + event.setLevelMetadata(levels.LevelFatal) return event } // Print prints a string on screen without any extra labels. func (l *Logger) Print() *Event { - level := levels.LevelSilent - event := &Event{ - logger: l, - level: level, - metadata: make(map[string]string), - } + event := newEventWithLevelAndLogger(levels.LevelSilent, l) return event } // Verbose prints a string only in verbose output mode. func (l *Logger) Verbose() *Event { - level := levels.LevelVerbose - event := &Event{ - logger: l, - level: level, - metadata: make(map[string]string), - } - event.metadata["label"] = labels[level] + event := newEventWithLevelAndLogger(levels.LevelVerbose, l) + event.setLevelMetadata(levels.LevelVerbose) return event } -// SetTimestamp sets a global flag indicating whether or not to add timestamps to debug logs. -// If the flag is set to true, timestamps will be added to debug logs. -func (l *Logger) SetTimestamp(timestamp bool) { - DefaultLogger.addTimestamp = timestamp -} - func isCurrentLevelEnabled(e *Event) bool { return e.level <= e.logger.maxLevel } From 1c357ca8209ba846569ee627a4a178833e745c18 Mon Sep 17 00:00:00 2001 From: Mzack9999 Date: Wed, 4 Jan 2023 08:52:07 +0100 Subject: [PATCH 5/5] updating example --- examples/basic/basic.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/examples/basic/basic.go b/examples/basic/basic.go index 87f5f61..dc5b22f 100644 --- a/examples/basic/basic.go +++ b/examples/basic/basic.go @@ -18,5 +18,11 @@ func main() { gologger.Debug().Str("state", "running").Msg("planner running") gologger.Debug().TimeStamp().Str("state", "running").Msg("with timestamp event") gologger.Warning().Str("state", "errored").Str("status", "404").Msg("could not run") + + // with timestamp + gologger.DefaultLogger.SetTimestamp(true, levels.LevelDebug) + gologger.Debug().Msg("with automatic timestamp") + gologger.Info().Msg("without automatic timestamp") + gologger.Fatal().Msg("bye bye") }