diff --git a/README.md b/README.md index 64dcd92..11b38cb 100644 --- a/README.md +++ b/README.md @@ -49,7 +49,7 @@ By default, root logger prints on console only, and starting from Warning level. level: ```go -logger.Configure(logger.NewConfiguration(logger.WithFromLevel(loglevel.All))) +logger.Configure(logger.NewConfiguration(logger.WithFromLevel(level.All))) ``` After changing log level to "None" it will print messages for any level. @@ -81,27 +81,27 @@ There are three predefined types of handler: messages, and formatter that tells how to log message. It logs messages to standard output. ```go -newConsoleHandler := handler.NewConsoleHandler(loglevel.Debug, loglevel.Null, applicationFormatter) +newConsoleHandler := handler.NewConsoleHandler(level.Debug, level.Null, applicationFormatter) ``` - Console Error Handler - it takes log level starting from which it would log messages, log level till which it would log messages, and formatter that tells how to log message. It logs messages to error output. ```go -newConsoleErrorHandler := handler.NewConsoleErrorHandler(loglevel.Debug, loglevel.Null, applicationFormatter) +newConsoleErrorHandler := handler.NewConsoleErrorHandler(level.Debug, level.Null, applicationFormatter) ``` - File Handler - it takes log level starting from which it would log messages, log level till which it would log messages, formatter that tells how to log message, and path to the file where to log those data. ```go -newFileHandler := handler.NewFileHandler(loglevel.Debug, loglevel.Null, applicationFormatter, "system.log") +newFileHandler := handler.NewFileHandler(level.Debug, level.Null, applicationFormatter, "system.log") ``` You could create your custom handler: ```go -customHandler := handler.New(loglevel.Debug, loglevel.Null, applicationFormatter, os.Stdout) +customHandler := handler.New(level.Debug, level.Null, applicationFormatter, os.Stdout) ``` It takes two additional arguments writer for standard messages and for error messages. Standard message logs till diff --git a/docs/architecture/diagrams/plantuml/class_diagram.plantuml b/docs/architecture/diagrams/plantuml/class_diagram.plantuml index 5e510e7..9e97d4d 100644 --- a/docs/architecture/diagrams/plantuml/class_diagram.plantuml +++ b/docs/architecture/diagrams/plantuml/class_diagram.plantuml @@ -5,19 +5,19 @@ package pkg.logger { package formatter { interface Interface { + Template() : string - + Format(message : string, loggerName : string, level : loglevel.LogLevel, colored : bool) : string + + Format(message : string, loggerName : string, level : level.Level, colored : bool) : string } struct Formatter implements Interface { ~ template : string + IsEqual(anotherFormatter : *Formatter) : bool - + EvaluatePreset(message : string, loggerName : string, level : loglevel.LogLevel) : map[string]string + + EvaluatePreset(message : string, loggerName : string, level : level.Level) : map[string]string + Template() : string - + Format(message : string, loggerName : string, level : loglevel.LogLevel, colored : bool) : string + + Format(message : string, loggerName : string, level : level.Level, colored : bool) : string } class "<>" { - ~ logLevelColors : map[loglevel.LogLevel]string + ~ logLevelColors : map[level.Level]string ~ resetColor : string + New(template : string) : *Formatter } @@ -27,66 +27,66 @@ package pkg.logger { package handler { interface Interface { + Writer() : io.Writer - + FromLevel() loglevel.LogLevel - + SetFromLevel(fromLevel loglevel.LogLevel) - + ToLevel() loglevel.LogLevel - + SetToLevel(toLevel loglevel.LogLevel) + + FromLevel() level.Level + + SetFromLevel(fromLevel level.Level) + + ToLevel() level.Level + + SetToLevel(toLevel level.Level) + Formatter() : formatter.Interface - + Write(logName : string, level : loglevel.LogLevel, message : string, parameters : ...any) + + Write(logName : string, level : level.Level, message : string, parameters : ...any) } struct Handler implements Interface { - ~ fromLevel : loglevel.LogLevel - ~ toLevel : loglevel.LogLevel + ~ fromLevel : level.Level + ~ toLevel : level.Level ~ formatter : formatter.Interface ~ writer : io.Writer ~ consoleSupportsANSIColors : func() bool + Writer() : io.Writer - + FromLevel() : loglevel.LogLevel - + SetLevel(level : loglevel.LogLevel) - + ToLevel() : loglevel.LogLevel - + SetToLevel(level : loglevel.LogLevel) + + FromLevel() : level.Level + + SetLevel(level : level.Level) + + ToLevel() : level.Level + + SetToLevel(level : level.Level) + Formatter() : formatter.Interface - + Write(logName : string, level : loglevel.LogLevel, message : string, parameters : ...any) + + Write(logName : string, level : level.Level, message : string, parameters : ...any) } class "<>" { ~ osOpenFile : os.OpenFile(name : string, flag : int, perm : FileMode) : (*File, error) ~ osStdout : *File ~ osStderr : *File - + New(fromLevel : loglevel.LogLevel, toLevel : loglevel.LogLevel, newFormatter : formatter.Interface, writer : io.Writer, errorWriter : io.Writer) : *Handler - + NewConsoleHandler(fromLevel : loglevel.LogLevel, toLevel : loglevel.LogLevel, newFormatter : formatter.Interface) : *Handler - + NewConsoleErrorHandler(fromLevel : loglevel.LogLevel, toLevel : loglevel.LogLevel, newFormatter : formatter.Interface) : *Handler - + NewFileHandler(fromLevel : loglevel.LogLevel, toLevel : loglevel.LogLevel, newFormatter : formatter.Interface, file : string) : *Handler + + New(fromLevel : level.Level, toLevel : level.Level, newFormatter : formatter.Interface, writer : io.Writer, errorWriter : io.Writer) : *Handler + + NewConsoleHandler(fromLevel : level.Level, toLevel : level.Level, newFormatter : formatter.Interface) : *Handler + + NewConsoleErrorHandler(fromLevel : level.Level, toLevel : level.Level, newFormatter : formatter.Interface) : *Handler + + NewFileHandler(fromLevel : level.Level, toLevel : level.Level, newFormatter : formatter.Interface, file : string) : *Handler ~ consoleSupportsANSIColors() : bool } "<>" ..> Handler : uses } - package loglevel { - stereotype LogLevel <> { + package level { + stereotype Level <> { + String() : string + DigitRepresentation() : int - + Next() : LogLevel - + Previous() : LogLevel + + Next() : Level + + Previous() : Level } class "<>" { - + All : loglevel.LogLevel - + Trace : loglevel.LogLevel - + Debug : loglevel.LogLevel - + Verbose : loglevel.LogLevel - + Info : loglevel.LogLevel - + Notice : loglevel.LogLevel - + Warning : loglevel.LogLevel - + Severe : loglevel.LogLevel - + Error : loglevel.LogLevel - + Alert : loglevel.LogLevel - + Critical : loglevel.LogLevel - + Emergency : loglevel.LogLevel - + Null : loglevel.LogLevel + + All : level.Level + + Trace : level.Level + + Debug : level.Level + + Verbose : level.Level + + Info : level.Level + + Notice : level.Level + + Warning : level.Level + + Severe : level.Level + + Error : level.Level + + Alert : level.Level + + Critical : level.Level + + Emergency : level.Level + + Null : level.Level } - "<>" ..> LogLevel : uses + "<>" ..> Level : uses } interface baseLoggerInterface { - + Log(level : loglevel.LogLevel, message : string, parameters : ...any) + + Log(level : level.Level, message : string, parameters : ...any) + Name() : string + SetName(name : string) + Handlers() : []handler.Interface @@ -96,7 +96,7 @@ package pkg.logger { struct baseLogger implements baseLoggerInterface { ~ name : string ~ handlers : []handler.Interface - + Log(level : loglevel.LogLevel, message : string, parameters : ...any) + + Log(level : level.Level, message : string, parameters : ...any) + Name() : string + SetName(name : string) + Handlers() : []handler.Interface @@ -139,8 +139,8 @@ package pkg.logger { + Emergency(message : string, parameters : ...any) } struct Configuration { - ~ fromLevel : loglevel.LogLevel - ~ toLevel : loglevel.LogLevel + ~ fromLevel : level.Level + ~ toLevel : level.Level ~ template : string ~ file : string ~ name : string @@ -148,13 +148,13 @@ package pkg.logger { stereotype Option <> {} class "<>" { ~ rootLogger : *Logger - ~ fromLevel : loglevel.LogLevel - ~ toLevel : loglevel.LogLevel + ~ fromLevel : level.Level + ~ toLevel : level.Level ~ template : string ~ init() + New(name : string) : *Logger - + WithFromLevel(fromLevel : loglevel.LogLevel) : Option - + WithToLevel(toLevel : loglevel.LogLevel) : Option + + WithFromLevel(fromLevel : level.Level) : Option + + WithToLevel(toLevel : level.Level) : Option + WithTemplate(template : string) : Option + WithFile(file : string) : Option + WithName(name : string) : Option @@ -162,8 +162,8 @@ package pkg.logger { + Configure(configuration : *Configuration) + Name() : string + Template() : string - + FromLevel() : loglevel.LogLevel - + ToLevel() : loglevel.LogLevel + + FromLevel() : level.Level + + ToLevel() : level.Level + Trace(message : string, parameters : ...any) + Debug(message : string, parameters : ...any) + Verbose(message : string, parameters : ...any) @@ -184,7 +184,7 @@ package pkg.logger { Option ..> Configuration : uses } -pkg.logger.handler.Handler *-- pkg.logger.loglevel.LogLevel : contains +pkg.logger.handler.Handler *-- pkg.logger.level.Level : contains pkg.logger.handler.Handler *-- pkg.logger.formatter.Interface : contains pkg.logger.baseLogger *-- "0..*" pkg.logger.handler.Interface : contains diff --git a/docs/architecture/diagrams/png/class_diagram.png b/docs/architecture/diagrams/png/class_diagram.png index 49b2f03..fce7b82 100644 Binary files a/docs/architecture/diagrams/png/class_diagram.png and b/docs/architecture/diagrams/png/class_diagram.png differ diff --git a/docs/architecture/diagrams/svg/class_diagram.svg b/docs/architecture/diagrams/svg/class_diagram.svg index e30c923..55939fb 100644 --- a/docs/architecture/diagrams/svg/class_diagram.svg +++ b/docs/architecture/diagrams/svg/class_diagram.svg @@ -1,1063 +1 @@ - - - - - - - - pkg - - - - - - logger - - - - - - formatter - - - - - - handler - - - - - - loglevel - - - - - - - baseLoggerInterface - - - - - Log(level : loglevel.LogLevel, message : string, parameters : ...any) - - - Name() : string - - - SetName(name : string) - - - Handlers() : []handler.Interface - - - AddHandler(handlerInterface : handler.Interface) - - - RemoveHandler(handlerInterface : handler.Interface) - - - - - - - baseLogger - - - - name : string - - - handlers : []handler.Interface - - - - Log(level : loglevel.LogLevel, message : string, parameters : ...any) - - - Name() : string - - - SetName(name : string) - - - Handlers() : []handler.Interface - - - AddHandler(handlerInterface : handler.Interface) - - - RemoveHandler(handlerInterface : handler.Interface) - - - - - - - Interface - - - - - Name() : string - - - Handlers() : []handler.Interface - - - AddHandler(handlerInterface : handler.Interface) - - - RemoveHandler(handlerInterface : handler.Interface) - - - Trace(message : string, parameters : ...any) - - - Debug(message : string, parameters : ...any) - - - Verbose(message : string, parameters : ...any) - - - Info(message : string, parameters : ...any) - - - Notice(message : string, parameters : ...any) - - - Warning(message : string, parameters : ...any) - - - Severe(message : string, parameters : ...any) - - - Error(message : string, parameters : ...any) - - - Alert(message : string, parameters : ...any) - - - Critical(message : string, parameters : ...any) - - - Emergency(message : string, parameters : ...any) - - - - - - - Logger - - - - baseLogger : baseLoggerInterface - - - - Name() : string - - - Handlers() : []handler.Interface - - - AddHandler(handlerInterface : handler.Interface) - - - RemoveHandler(handlerInterface : handler.Interface) - - - Trace(message : string, parameters : ...any) - - - Debug(message : string, parameters : ...any) - - - Verbose(message : string, parameters : ...any) - - - Info(message : string, parameters : ...any) - - - Notice(message : string, parameters : ...any) - - - Warning(message : string, parameters : ...any) - - - Severe(message : string, parameters : ...any) - - - Error(message : string, parameters : ...any) - - - Alert(message : string, parameters : ...any) - - - Critical(message : string, parameters : ...any) - - - Emergency(message : string, parameters : ...any) - - - - - - - Configuration - - - - fromLevel : loglevel.LogLevel - - - toLevel : loglevel.LogLevel - - - template : string - - - file : string - - - name : string - - - - - - - - «func(*Configuration)» - - Option - - - - - - - - - «module» - - - - rootLogger : *Logger - - - fromLevel : loglevel.LogLevel - - - toLevel : loglevel.LogLevel - - - template : string - - - - init() - - - New(name : string) : *Logger - - - WithFromLevel(fromLevel : loglevel.LogLevel) : Option - - - WithToLevel(toLevel : loglevel.LogLevel) : Option - - - WithTemplate(template : string) : Option - - - WithFile(file : string) : Option - - - WithName(name : string) : Option - - - NewConfiguration(options : ...Option) : *Configuration - - - Configure(configuration : *Configuration) - - - Name() : string - - - Template() : string - - - FromLevel() : loglevel.LogLevel - - - ToLevel() : loglevel.LogLevel - - - Trace(message : string, parameters : ...any) - - - Debug(message : string, parameters : ...any) - - - Verbose(message : string, parameters : ...any) - - - Info(message : string, parameters : ...any) - - - Notice(message : string, parameters : ...any) - - - Warning(message : string, parameters : ...any) - - - Severe(message : string, parameters : ...any) - - - Error(message : string, parameters : ...any) - - - Alert(message : string, parameters : ...any) - - - Critical(message : string, parameters : ...any) - - - Emergency(message : string, parameters : ...any) - - - - - - - Interface - - - - - Template() : string - - - Format(message : string, loggerName : string, level : loglevel.LogLevel, - colored : bool) : string - - - - - - - Formatter - - - - template : string - - - - IsEqual(anotherFormatter : *Formatter) : bool - - - EvaluatePreset(message : string, loggerName : string, level : - loglevel.LogLevel) : map[string]string - - - Template() : string - - - Format(message : string, loggerName : string, level : loglevel.LogLevel, - colored : bool) : string - - - - - - - «module» - - - - logLevelColors : map[loglevel.LogLevel]string - - - resetColor : string - - - - New(template : string) : *Formatter - - - - - - - Interface - - - - - Writer() : io.Writer - - - FromLevel() loglevel.LogLevel - - - SetFromLevel(fromLevel loglevel.LogLevel) - - - ToLevel() loglevel.LogLevel - - - SetToLevel(toLevel loglevel.LogLevel) - - - Formatter() : formatter.Interface - - - Write(logName : string, level : loglevel.LogLevel, message : string, - parameters : ...any) - - - - - - - Handler - - - - fromLevel : loglevel.LogLevel - - - toLevel : loglevel.LogLevel - - - formatter : formatter.Interface - - - writer : io.Writer - - - - consoleSupportsANSIColors : func() bool - - - Writer() : io.Writer - - - FromLevel() : loglevel.LogLevel - - - SetLevel(level : loglevel.LogLevel) - - - ToLevel() : loglevel.LogLevel - - - SetToLevel(level : loglevel.LogLevel) - - - Formatter() : formatter.Interface - - - Write(logName : string, level : loglevel.LogLevel, message : string, - parameters : ...any) - - - - - - - «module» - - - - osStdout : *File - - - osStderr : *File - - - - osOpenFile : os.OpenFile(name : string, flag : int, perm : FileMode) : (*File, - error) - - - New(fromLevel : loglevel.LogLevel, toLevel : loglevel.LogLevel, newFormatter : - formatter.Interface, writer : io.Writer, errorWriter : io.Writer) : *Handler - - - NewConsoleHandler(fromLevel : loglevel.LogLevel, toLevel : loglevel.LogLevel, - newFormatter : formatter.Interface) : *Handler - - - NewConsoleErrorHandler(fromLevel : loglevel.LogLevel, toLevel : - loglevel.LogLevel, newFormatter : formatter.Interface) : *Handler - - - NewFileHandler(fromLevel : loglevel.LogLevel, toLevel : loglevel.LogLevel, - newFormatter : formatter.Interface, file : string) : *Handler - - - consoleSupportsANSIColors() : bool - - - - - - - «int» - - LogLevel - - - - - String() : string - - - DigitRepresentation() : int - - - Next() : LogLevel - - - Previous() : LogLevel - - - - - - - «module» - - - - All : loglevel.LogLevel - - - Trace : loglevel.LogLevel - - - Debug : loglevel.LogLevel - - - Verbose : loglevel.LogLevel - - - Info : loglevel.LogLevel - - - Notice : loglevel.LogLevel - - - Warning : loglevel.LogLevel - - - Severe : loglevel.LogLevel - - - Error : loglevel.LogLevel - - - Alert : loglevel.LogLevel - - - Critical : loglevel.LogLevel - - - Emergency : loglevel.LogLevel - - - Null : loglevel.LogLevel - - - - - - - - - - - uses - - - - - - - - - - uses - - - - - - uses - - - - - - - - - - - - - - - - - - uses - - - - - - uses - - - - - - uses - - - - - - uses - - - - - - contains - - - - - - contains - - - - - - contains - - 0..* - - - - \ No newline at end of file +pkgloggerformatterhandlerlevelbaseLoggerInterfaceLog(level : level.Level, message : string, parameters : ...any)Name() : stringSetName(name : string)Handlers() : []handler.InterfaceAddHandler(handlerInterface : handler.Interface)RemoveHandler(handlerInterface : handler.Interface)baseLoggername : stringhandlers : []handler.InterfaceLog(level : level.Level, message : string, parameters : ...any)Name() : stringSetName(name : string)Handlers() : []handler.InterfaceAddHandler(handlerInterface : handler.Interface)RemoveHandler(handlerInterface : handler.Interface)InterfaceName() : stringHandlers() : []handler.InterfaceAddHandler(handlerInterface : handler.Interface)RemoveHandler(handlerInterface : handler.Interface)Trace(message : string, parameters : ...any)Debug(message : string, parameters : ...any)Verbose(message : string, parameters : ...any)Info(message : string, parameters : ...any)Notice(message : string, parameters : ...any)Warning(message : string, parameters : ...any)Severe(message : string, parameters : ...any)Error(message : string, parameters : ...any)Alert(message : string, parameters : ...any)Critical(message : string, parameters : ...any)Emergency(message : string, parameters : ...any)LoggerbaseLogger : baseLoggerInterfaceName() : stringHandlers() : []handler.InterfaceAddHandler(handlerInterface : handler.Interface)RemoveHandler(handlerInterface : handler.Interface)Trace(message : string, parameters : ...any)Debug(message : string, parameters : ...any)Verbose(message : string, parameters : ...any)Info(message : string, parameters : ...any)Notice(message : string, parameters : ...any)Warning(message : string, parameters : ...any)Severe(message : string, parameters : ...any)Error(message : string, parameters : ...any)Alert(message : string, parameters : ...any)Critical(message : string, parameters : ...any)Emergency(message : string, parameters : ...any)ConfigurationfromLevel : level.LeveltoLevel : level.Leveltemplate : stringfile : stringname : string«func(*Configuration)»Option«module»rootLogger : *LoggerfromLevel : level.LeveltoLevel : level.Leveltemplate : stringinit()New(name : string) : *LoggerWithFromLevel(fromLevel : level.Level) : OptionWithToLevel(toLevel : level.Level) : OptionWithTemplate(template : string) : OptionWithFile(file : string) : OptionWithName(name : string) : OptionNewConfiguration(options : ...Option) : *ConfigurationConfigure(configuration : *Configuration)Name() : stringTemplate() : stringFromLevel() : level.LevelToLevel() : level.LevelTrace(message : string, parameters : ...any)Debug(message : string, parameters : ...any)Verbose(message : string, parameters : ...any)Info(message : string, parameters : ...any)Notice(message : string, parameters : ...any)Warning(message : string, parameters : ...any)Severe(message : string, parameters : ...any)Error(message : string, parameters : ...any)Alert(message : string, parameters : ...any)Critical(message : string, parameters : ...any)Emergency(message : string, parameters : ...any)InterfaceTemplate() : stringFormat(message : string, loggerName : string, level : level.Level, colored : bool) : stringFormattertemplate : stringIsEqual(anotherFormatter : *Formatter) : boolEvaluatePreset(message : string, loggerName : string, level : level.Level) : map[string]stringTemplate() : stringFormat(message : string, loggerName : string, level : level.Level, colored : bool) : string«module»logLevelColors : map[level.Level]stringresetColor : stringNew(template : string) : *FormatterInterfaceWriter() : io.WriterFromLevel() level.LevelSetFromLevel(fromLevel level.Level)ToLevel() level.LevelSetToLevel(toLevel level.Level)Formatter() : formatter.InterfaceWrite(logName : string, level : level.Level, message : string, parameters : ...any)HandlerfromLevel : level.LeveltoLevel : level.Levelformatter : formatter.Interfacewriter : io.WriterconsoleSupportsANSIColors : func() boolWriter() : io.WriterFromLevel() : level.LevelSetLevel(level : level.Level)ToLevel() : level.LevelSetToLevel(level : level.Level)Formatter() : formatter.InterfaceWrite(logName : string, level : level.Level, message : string, parameters : ...any)«module»osStdout : *FileosStderr : *FileosOpenFile : os.OpenFile(name : string, flag : int, perm : FileMode) : (*File, error)New(fromLevel : level.Level, toLevel : level.Level, newFormatter : formatter.Interface, writer : io.Writer, errorWriter : io.Writer) : *HandlerNewConsoleHandler(fromLevel : level.Level, toLevel : level.Level, newFormatter : formatter.Interface) : *HandlerNewConsoleErrorHandler(fromLevel : level.Level, toLevel : level.Level, newFormatter : formatter.Interface) : *HandlerNewFileHandler(fromLevel : level.Level, toLevel : level.Level, newFormatter : formatter.Interface, file : string) : *HandlerconsoleSupportsANSIColors() : bool«int»LevelString() : stringDigitRepresentation() : intNext() : LevelPrevious() : Level«module»All : level.LevelTrace : level.LevelDebug : level.LevelVerbose : level.LevelInfo : level.LevelNotice : level.LevelWarning : level.LevelSevere : level.LevelError : level.LevelAlert : level.LevelCritical : level.LevelEmergency : level.LevelNull : level.Levelusesusesusesusesusesusesusescontainscontainscontains0..* \ No newline at end of file diff --git a/examples/customlogger/main.go b/examples/customlogger/main.go index bc82630..f18600f 100644 --- a/examples/customlogger/main.go +++ b/examples/customlogger/main.go @@ -5,7 +5,7 @@ import ( "github.com/dl1998/go-logging/pkg/logger" "github.com/dl1998/go-logging/pkg/logger/formatter" "github.com/dl1998/go-logging/pkg/logger/handler" - "github.com/dl1998/go-logging/pkg/logger/loglevel" + "github.com/dl1998/go-logging/pkg/logger/level" ) func main() { @@ -14,16 +14,16 @@ func main() { applicationLogger.Debug("This message will not be displayed, because there are no handlers registered.") applicationFormatter := formatter.New("%(isotime) [%(level)] %(message)") - consoleHandler := handler.NewConsoleHandler(loglevel.Debug, loglevel.Null, applicationFormatter) + consoleHandler := handler.NewConsoleHandler(level.Debug, level.Null, applicationFormatter) applicationLogger.AddHandler(consoleHandler) applicationLogger.Warning("This message will be displayed.") - applicationLogger.Debug("This message will be displayed, because LogLevel of custom logger set to Debug.") + applicationLogger.Debug("This message will be displayed, because Level of custom logger set to Debug.") applicationLogger.Trace("This message will not be displayed, because Trace has lower level than Debug.") - consoleHandler.SetFromLevel(loglevel.Trace) + consoleHandler.SetFromLevel(level.Trace) - applicationLogger.Trace("This message will be displayed, because LogLevel has been changed to Trace.") + applicationLogger.Trace("This message will be displayed, because Level has been changed to Trace.") } diff --git a/examples/defaultlogger/main.go b/examples/defaultlogger/main.go index 1964bec..8a1ad0b 100644 --- a/examples/defaultlogger/main.go +++ b/examples/defaultlogger/main.go @@ -3,15 +3,15 @@ package main import ( "github.com/dl1998/go-logging/pkg/logger" - "github.com/dl1998/go-logging/pkg/logger/loglevel" + "github.com/dl1998/go-logging/pkg/logger/level" ) func main() { - logger.Debug("This message will not be displayed, as default LogLevel is Warning.") + logger.Debug("This message will not be displayed, as default Level is Warning.") logger.Warning("This message will be displayed.") - logger.Configure(logger.NewConfiguration(logger.WithFromLevel(loglevel.All))) + logger.Configure(logger.NewConfiguration(logger.WithFromLevel(level.All))) - logger.Debug("This message will be displayed, because LogLevel has been changed.") + logger.Debug("This message will be displayed, because Level has been changed.") } diff --git a/examples/logtofile/main.go b/examples/logtofile/main.go index f749c3e..361ab7a 100644 --- a/examples/logtofile/main.go +++ b/examples/logtofile/main.go @@ -6,7 +6,7 @@ import ( "github.com/dl1998/go-logging/pkg/logger" "github.com/dl1998/go-logging/pkg/logger/formatter" "github.com/dl1998/go-logging/pkg/logger/handler" - "github.com/dl1998/go-logging/pkg/logger/loglevel" + "github.com/dl1998/go-logging/pkg/logger/level" "os" ) @@ -24,7 +24,7 @@ func main() { applicationLogger := logger.New("file-logger") applicationFormatter := formatter.New("%(isotime) [%(level)] %(message)") - fileHandler := handler.NewFileHandler(loglevel.Warning, loglevel.Null, applicationFormatter, fmt.Sprintf("%s/file.log", directory)) + fileHandler := handler.NewFileHandler(level.Warning, level.Null, applicationFormatter, fmt.Sprintf("%s/file.log", directory)) applicationLogger.AddHandler(fileHandler) applicationLogger.Warning("This file has only Warning level logs or higher.") diff --git a/pkg/logger/formatter/formatter.go b/pkg/logger/formatter/formatter.go index c699315..3d1ee3e 100644 --- a/pkg/logger/formatter/formatter.go +++ b/pkg/logger/formatter/formatter.go @@ -3,26 +3,26 @@ package formatter import ( - "github.com/dl1998/go-logging/pkg/logger/loglevel" + "github.com/dl1998/go-logging/pkg/logger/level" "runtime" "strconv" "strings" "time" ) -// logLevelColors maps LogLevel values to ANSI color codes. -var logLevelColors = map[loglevel.LogLevel]string{ - loglevel.Trace: "\033[90m", // Dark Grey - loglevel.Debug: "\033[36m", // Cyan - loglevel.Verbose: "\033[96m", // Light Cyan - loglevel.Info: "\033[97m", // Default terminal text color (ANSI Bright White) - loglevel.Notice: "\033[94m", // Light Blue - loglevel.Warning: "\033[93m", // Bright Yellow - loglevel.Severe: "\033[38;5;208m", // Orange - loglevel.Error: "\033[31m", // Red - loglevel.Alert: "\033[38;5;202m", // Dark Orange - loglevel.Critical: "\033[1;31m", // Red or magenta (ANSI Bright Magenta) - loglevel.Emergency: "\033[97m\033[41m", // Bright White on Red Background +// logLevelColors maps level.Level values to ANSI color codes. +var logLevelColors = map[level.Level]string{ + level.Trace: "\033[90m", // Dark Grey + level.Debug: "\033[36m", // Cyan + level.Verbose: "\033[96m", // Light Cyan + level.Info: "\033[97m", // Default terminal text color (ANSI Bright White) + level.Notice: "\033[94m", // Light Blue + level.Warning: "\033[93m", // Bright Yellow + level.Severe: "\033[38;5;208m", // Orange + level.Error: "\033[31m", // Red + level.Alert: "\033[38;5;202m", // Dark Orange + level.Critical: "\033[1;31m", // Red or magenta (ANSI Bright Magenta) + level.Emergency: "\033[97m\033[41m", // Bright White on Red Background } // Reset color @@ -31,7 +31,7 @@ const resetColor = "\033[0m" // Interface represents interface that shall be satisfied by Formatter. type Interface interface { Template() string - Format(message string, loggerName string, level loglevel.LogLevel, colored bool) string + Format(message string, loggerName string, logLevel level.Level, colored bool) string } // Formatter struct that contains necessary for the formatting fields. @@ -52,19 +52,19 @@ func (formatter *Formatter) IsEqual(anotherFormatter *Formatter) bool { // EvaluatePreset evaluates pre-defined set of formatting options and returns map // with mapping of the option to interpolated value. -func (formatter *Formatter) EvaluatePreset(message string, loggerName string, level loglevel.LogLevel) map[string]string { +func (formatter *Formatter) EvaluatePreset(message string, loggerName string, logLevel level.Level) map[string]string { _, functionName, functionLine, _ := runtime.Caller(2) var presets = map[string]string{ - "%(name)": loggerName, // Logger name - "%(message)": message, // Logged message - "%(time)": time.Now().Format(time.TimeOnly), // Current time (format: HH:MM:ss) - "%(date)": time.Now().Format(time.DateOnly), // Current date (format: yyyy-mm-dd) - "%(isotime)": time.Now().Format(time.RFC3339), // Current date and time (format: yyyy-mm-ddTHH:MM:ssGMT) - "%(timestamp)": strconv.FormatInt(time.Now().Unix(), 10), // Current timestamp - "%(level)": level.String(), // Logging level name - "%(levelnr)": strconv.Itoa(level.DigitRepresentation()), // Logging level number - "%(fname)": functionName, // Name of the function from which logger has been called - "%(fline)": strconv.Itoa(functionLine), // Line number from which logger has been called + "%(name)": loggerName, // Logger name + "%(message)": message, // Logged message + "%(time)": time.Now().Format(time.TimeOnly), // Current time (format: HH:MM:ss) + "%(date)": time.Now().Format(time.DateOnly), // Current date (format: yyyy-mm-dd) + "%(isotime)": time.Now().Format(time.RFC3339), // Current date and time (format: yyyy-mm-ddTHH:MM:ssGMT) + "%(timestamp)": strconv.FormatInt(time.Now().Unix(), 10), // Current timestamp + "%(level)": logLevel.String(), // Logging log level name + "%(levelnr)": strconv.Itoa(logLevel.DigitRepresentation()), // Logging log level number + "%(fname)": functionName, // Name of the function from which logger has been called + "%(fline)": strconv.Itoa(functionLine), // Line number from which logger has been called } return presets } @@ -75,8 +75,8 @@ func (formatter *Formatter) Template() string { } // Format formats provided message template to the interpolated string. -func (formatter *Formatter) Format(message string, loggerName string, level loglevel.LogLevel, colored bool) string { - var presets = formatter.EvaluatePreset(message, loggerName, level) +func (formatter *Formatter) Format(message string, loggerName string, logLevel level.Level, colored bool) string { + var presets = formatter.EvaluatePreset(message, loggerName, logLevel) format := formatter.template @@ -85,7 +85,7 @@ func (formatter *Formatter) Format(message string, loggerName string, level logl } if colored { - format = logLevelColors[level] + format + resetColor + format = logLevelColors[logLevel] + format + resetColor } return format + "\n" diff --git a/pkg/logger/formatter/formatter_test.go b/pkg/logger/formatter/formatter_test.go index a3eba12..1c1cf34 100644 --- a/pkg/logger/formatter/formatter_test.go +++ b/pkg/logger/formatter/formatter_test.go @@ -4,14 +4,14 @@ package formatter import ( "fmt" "github.com/dl1998/go-logging/internal/testutils" - "github.com/dl1998/go-logging/pkg/logger/loglevel" + "github.com/dl1998/go-logging/pkg/logger/level" "testing" ) var template = "%(level):%(name):%(message)" var message = "Test message." var loggerName = "test" -var loggingLevel = loglevel.LogLevel(loglevel.Debug) +var loggingLevel = level.Debug // TestNew tests that New create correct Formatter instance. func TestNew(t *testing.T) { diff --git a/pkg/logger/handler/handler.go b/pkg/logger/handler/handler.go index fa51b90..122e8dc 100644 --- a/pkg/logger/handler/handler.go +++ b/pkg/logger/handler/handler.go @@ -5,7 +5,7 @@ package handler import ( "fmt" "github.com/dl1998/go-logging/pkg/logger/formatter" - "github.com/dl1998/go-logging/pkg/logger/loglevel" + "github.com/dl1998/go-logging/pkg/logger/level" "io" "os" "strings" @@ -18,26 +18,26 @@ var osStderr = os.Stderr // Interface represents interface that shall be satisfied by Handler. type Interface interface { Writer() io.Writer - FromLevel() loglevel.LogLevel - SetFromLevel(fromLevel loglevel.LogLevel) - ToLevel() loglevel.LogLevel - SetToLevel(toLevel loglevel.LogLevel) + FromLevel() level.Level + SetFromLevel(fromLevel level.Level) + ToLevel() level.Level + SetToLevel(toLevel level.Level) Formatter() formatter.Interface - Write(logName string, level loglevel.LogLevel, message string, parameters ...any) + Write(logName string, logLevel level.Level, message string, parameters ...any) } // Handler struct contains information where it shall write log message, how to // format them and their log fromLevel. type Handler struct { - fromLevel loglevel.LogLevel - toLevel loglevel.LogLevel + fromLevel level.Level + toLevel level.Level formatter formatter.Interface writer io.Writer consoleSupportsANSIColors func() bool } // New create a new instance of the Handler. -func New(fromLevel loglevel.LogLevel, toLevel loglevel.LogLevel, newFormatter formatter.Interface, writer io.Writer) *Handler { +func New(fromLevel level.Level, toLevel level.Level, newFormatter formatter.Interface, writer io.Writer) *Handler { return &Handler{ fromLevel: fromLevel, toLevel: toLevel, @@ -49,19 +49,19 @@ func New(fromLevel loglevel.LogLevel, toLevel loglevel.LogLevel, newFormatter fo // NewConsoleHandler create a new instance of the Handler that writes log // messages to the os.Stdout. -func NewConsoleHandler(fromLevel loglevel.LogLevel, toLevel loglevel.LogLevel, newFormatter formatter.Interface) *Handler { +func NewConsoleHandler(fromLevel level.Level, toLevel level.Level, newFormatter formatter.Interface) *Handler { return New(fromLevel, toLevel, newFormatter, osStdout) } // NewConsoleErrorHandler create a new instance of the Handler that writes log // messages to the os.Stderr. -func NewConsoleErrorHandler(fromLevel loglevel.LogLevel, toLevel loglevel.LogLevel, newFormatter formatter.Interface) *Handler { +func NewConsoleErrorHandler(fromLevel level.Level, toLevel level.Level, newFormatter formatter.Interface) *Handler { return New(fromLevel, toLevel, newFormatter, osStderr) } // NewFileHandler creates a new instance of the Handler that writes log message // to the log file. -func NewFileHandler(fromLevel loglevel.LogLevel, toLevel loglevel.LogLevel, newFormatter formatter.Interface, file string) *Handler { +func NewFileHandler(fromLevel level.Level, toLevel level.Level, newFormatter formatter.Interface, file string) *Handler { writer, err := osOpenFile(file, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) if err != nil { @@ -78,22 +78,22 @@ func (handler *Handler) Writer() io.Writer { } // FromLevel returns log fromLevel of the Handler. -func (handler *Handler) FromLevel() loglevel.LogLevel { +func (handler *Handler) FromLevel() level.Level { return handler.fromLevel } // SetFromLevel sets a new log fromLevel for the Handler. -func (handler *Handler) SetFromLevel(fromLevel loglevel.LogLevel) { +func (handler *Handler) SetFromLevel(fromLevel level.Level) { handler.fromLevel = fromLevel } // ToLevel returns log toLevel of the Handler. -func (handler *Handler) ToLevel() loglevel.LogLevel { +func (handler *Handler) ToLevel() level.Level { return handler.toLevel } // SetToLevel sets a new log toLevel for the Handler. -func (handler *Handler) SetToLevel(toLevel loglevel.LogLevel) { +func (handler *Handler) SetToLevel(toLevel level.Level) { handler.toLevel = toLevel } @@ -103,8 +103,8 @@ func (handler *Handler) Formatter() formatter.Interface { } // Write writes log message to the defined by the Handler writer. -func (handler *Handler) Write(logName string, level loglevel.LogLevel, message string, parameters ...any) { - if level.DigitRepresentation() < handler.fromLevel.DigitRepresentation() || level.DigitRepresentation() > handler.toLevel.DigitRepresentation() { +func (handler *Handler) Write(logName string, logLevel level.Level, message string, parameters ...any) { + if logLevel.DigitRepresentation() < handler.fromLevel.DigitRepresentation() || logLevel.DigitRepresentation() > handler.toLevel.DigitRepresentation() { return } @@ -116,7 +116,7 @@ func (handler *Handler) Write(logName string, level loglevel.LogLevel, message s colored = true } - log := handler.formatter.Format(formattedMessage, logName, level, colored) + log := handler.formatter.Format(formattedMessage, logName, logLevel, colored) if _, err := handler.writer.Write([]byte(log)); err != nil { fmt.Println(err) diff --git a/pkg/logger/handler/handler_test.go b/pkg/logger/handler/handler_test.go index ea7662c..b5f80cb 100644 --- a/pkg/logger/handler/handler_test.go +++ b/pkg/logger/handler/handler_test.go @@ -6,7 +6,7 @@ import ( "fmt" "github.com/dl1998/go-logging/internal/testutils" "github.com/dl1998/go-logging/pkg/logger/formatter" - "github.com/dl1998/go-logging/pkg/logger/loglevel" + "github.com/dl1998/go-logging/pkg/logger/level" "io" "os" "testing" @@ -19,10 +19,10 @@ var testFile = "/tmp/test_file.log" func TestNew(t *testing.T) { newFormatter := formatter.New(template) - newHandler := New(loglevel.Debug, loglevel.Null, newFormatter, os.Stdout) + newHandler := New(level.Debug, level.Null, newFormatter, os.Stdout) - testutils.AssertEquals(t, loglevel.Debug, newHandler.fromLevel) - testutils.AssertEquals(t, loglevel.Null, newHandler.toLevel) + testutils.AssertEquals(t, level.Debug, newHandler.fromLevel) + testutils.AssertEquals(t, level.Null, newHandler.toLevel) if newHandler.writer != os.Stdout { t.Fatalf("writer is not the same. expected: %v, actual: %v", os.Stdout, newHandler.writer) @@ -34,7 +34,7 @@ func BenchmarkNew(b *testing.B) { newFormatter := formatter.New(template) for index := 0; index < b.N; index++ { - New(loglevel.Debug, loglevel.Null, newFormatter, os.Stdout) + New(level.Debug, level.Null, newFormatter, os.Stdout) } } @@ -43,9 +43,9 @@ func BenchmarkNew(b *testing.B) { func TestNewConsoleHandler(t *testing.T) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) - testutils.AssertEquals(t, loglevel.Debug, newHandler.fromLevel) + testutils.AssertEquals(t, level.Debug, newHandler.fromLevel) if newHandler.writer != os.Stdout { t.Fatalf("writer is not the same. expected: %v, actual: %v", os.Stdout, newHandler.writer) @@ -57,7 +57,7 @@ func BenchmarkNewConsoleHandler(b *testing.B) { newFormatter := formatter.New(template) for index := 0; index < b.N; index++ { - NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + NewConsoleHandler(level.Debug, level.Null, newFormatter) } } @@ -73,9 +73,9 @@ func TestNewFileHandler(t *testing.T) { osOpenFile = mockOpenFile - newHandler := NewFileHandler(loglevel.Debug, loglevel.Null, newFormatter, testFile) + newHandler := NewFileHandler(level.Debug, level.Null, newFormatter, testFile) - testutils.AssertEquals(t, loglevel.Debug, newHandler.fromLevel) + testutils.AssertEquals(t, level.Debug, newHandler.fromLevel) if newHandler.writer != os.Stdout { t.Fatalf("writer is not the same. expected: %v, actual: %v", os.Stdout, newHandler.writer) @@ -91,7 +91,7 @@ func TestNewFileHandlerError(t *testing.T) { return nil, fmt.Errorf("error") } - newHandler := NewFileHandler(loglevel.Debug, loglevel.Null, newFormatter, testFile) + newHandler := NewFileHandler(level.Debug, level.Null, newFormatter, testFile) testutils.AssertEquals(t, nil, newHandler) } @@ -103,7 +103,7 @@ func BenchmarkNewFileHandler(b *testing.B) { osOpenFile = mockOpenFile for index := 0; index < b.N; index++ { - NewFileHandler(loglevel.Debug, loglevel.Null, newFormatter, testFile) + NewFileHandler(level.Debug, level.Null, newFormatter, testFile) } } @@ -111,7 +111,7 @@ func BenchmarkNewFileHandler(b *testing.B) { func TestHandler_Writer(t *testing.T) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) if newHandler.Writer() != os.Stdout { t.Fatalf("writer is not the same. expected: %v, actual: %v", os.Stdout, newHandler.Writer()) @@ -122,7 +122,7 @@ func TestHandler_Writer(t *testing.T) { func BenchmarkHandler_Writer(b *testing.B) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) for index := 0; index < b.N; index++ { newHandler.Writer() @@ -134,7 +134,7 @@ func BenchmarkHandler_Writer(b *testing.B) { func TestHandler_FromLevel(t *testing.T) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) testutils.AssertEquals(t, newHandler.fromLevel, newHandler.FromLevel()) } @@ -143,7 +143,7 @@ func TestHandler_FromLevel(t *testing.T) { func BenchmarkHandler_FromLevel(b *testing.B) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) for index := 0; index < b.N; index++ { newHandler.FromLevel() @@ -155,9 +155,9 @@ func BenchmarkHandler_FromLevel(b *testing.B) { func TestHandler_SetFromLevel(t *testing.T) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) - newLevel := loglevel.Info + newLevel := level.Info newHandler.SetFromLevel(newLevel) @@ -169,9 +169,9 @@ func TestHandler_SetFromLevel(t *testing.T) { func BenchmarkHandler_SetFromLevel(b *testing.B) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) - newLevel := loglevel.Info + newLevel := level.Info for index := 0; index < b.N; index++ { newHandler.SetFromLevel(newLevel) @@ -182,7 +182,7 @@ func BenchmarkHandler_SetFromLevel(b *testing.B) { func TestHandler_ToLevel(t *testing.T) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) testutils.AssertEquals(t, newHandler.toLevel, newHandler.ToLevel()) } @@ -191,7 +191,7 @@ func TestHandler_ToLevel(t *testing.T) { func BenchmarkHandler_ToLevel(b *testing.B) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) for index := 0; index < b.N; index++ { newHandler.ToLevel() @@ -203,9 +203,9 @@ func BenchmarkHandler_ToLevel(b *testing.B) { func TestHandler_SetToLevel(t *testing.T) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) - newLevel := loglevel.Info + newLevel := level.Info newHandler.SetToLevel(newLevel) @@ -216,9 +216,9 @@ func TestHandler_SetToLevel(t *testing.T) { func BenchmarkHandler_SetToLevel(b *testing.B) { newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) - newLevel := loglevel.Info + newLevel := level.Info for index := 0; index < b.N; index++ { newHandler.SetToLevel(newLevel) @@ -230,7 +230,7 @@ func BenchmarkHandler_SetToLevel(b *testing.B) { func TestHandler_Formatter(t *testing.T) { var newFormatter formatter.Interface = formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) testutils.AssertEquals(t, newFormatter, newHandler.Formatter()) } @@ -239,7 +239,7 @@ func TestHandler_Formatter(t *testing.T) { func BenchmarkHandler_Formatter(b *testing.B) { var newFormatter formatter.Interface = formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) for index := 0; index < b.N; index++ { newHandler.Formatter() @@ -247,7 +247,7 @@ func BenchmarkHandler_Formatter(b *testing.B) { } // setupHandler is a helper function to setup a new handler for testing purposes. -func setupHandler(fromLevel, toLevel loglevel.LogLevel, supportsANSI bool, formatterTemplate string) *Handler { +func setupHandler(fromLevel, toLevel level.Level, supportsANSI bool, formatterTemplate string) *Handler { newFormatter := formatter.New(formatterTemplate) newHandler := NewConsoleHandler(fromLevel, toLevel, newFormatter) newHandler.consoleSupportsANSIColors = func() bool { @@ -260,7 +260,7 @@ func setupHandler(fromLevel, toLevel loglevel.LogLevel, supportsANSI bool, forma // correct writer. func TestHandler_Write(t *testing.T) { logName := "test" - logLevel := loglevel.Debug + logLevel := level.Debug message := "Test message." originalStdout := osStdout @@ -269,7 +269,7 @@ func TestHandler_Write(t *testing.T) { osStdout = writerStdout - handler := setupHandler(loglevel.Debug, loglevel.Null, true, template) + handler := setupHandler(level.Debug, level.Null, true, template) var bufferStdout bytes.Buffer @@ -287,7 +287,7 @@ func TestHandler_Write(t *testing.T) { // TestHandler_WriteError tests that Handler.Write() returns error if writer fails. func TestHandler_WriteError(t *testing.T) { logName := "test" - logLevel := loglevel.Debug + logLevel := level.Debug message := "Test message." originalStdout := osStdout @@ -296,7 +296,7 @@ func TestHandler_WriteError(t *testing.T) { osStdout = writerStdout - handler := setupHandler(loglevel.Warning, loglevel.Null, false, template) + handler := setupHandler(level.Warning, level.Null, false, template) var bufferStdout bytes.Buffer @@ -314,12 +314,12 @@ func TestHandler_WriteError(t *testing.T) { // BenchmarkHandler_Write performs benchmarking of the Handler.Write(). func BenchmarkHandler_Write(b *testing.B) { logName := "test" - logLevel := loglevel.Debug + logLevel := level.Debug message := "Test message." newFormatter := formatter.New(template) - newHandler := NewConsoleHandler(loglevel.Debug, loglevel.Null, newFormatter) + newHandler := NewConsoleHandler(level.Debug, level.Null, newFormatter) newHandler.writer = io.Discard diff --git a/pkg/logger/level/level.go b/pkg/logger/level/level.go new file mode 100644 index 0000000..28f4bdb --- /dev/null +++ b/pkg/logger/level/level.go @@ -0,0 +1,63 @@ +// Package level contains Level definition with supported levels. +package level + +type Level int + +const step = 5 + +const ( + All = Level(iota * step) + Trace + Debug + Verbose + Info + Notice + Warning + Severe + Error + Alert + Critical + Emergency + Null +) + +// String returns string representation of the Level. +func (level Level) String() string { + mapping := map[Level]string{ + All: "all", + Trace: "trace", + Debug: "debug", + Verbose: "verbose", + Info: "info", + Notice: "notice", + Warning: "warning", + Severe: "severe", + Error: "error", + Alert: "alert", + Critical: "critical", + Emergency: "emergency", + Null: "null", + } + return mapping[level] +} + +// DigitRepresentation returns digit representations of the Level. +func (level Level) DigitRepresentation() int { + return int(level) +} + +// Next returns next Level. +func (level Level) Next() Level { + if level == Null { + return level + } + return Level(level.DigitRepresentation() + step) +} + +// Previous returns previous Level. +func (level Level) Previous() Level { + if level == All { + return level + } + return Level(level.DigitRepresentation() - step) +} diff --git a/pkg/logger/loglevel/loglevel_test.go b/pkg/logger/level/level_test.go similarity index 77% rename from pkg/logger/loglevel/loglevel_test.go rename to pkg/logger/level/level_test.go index e711c62..a744865 100644 --- a/pkg/logger/loglevel/loglevel_test.go +++ b/pkg/logger/level/level_test.go @@ -1,15 +1,15 @@ -// Package loglevel_test has tests for loglevel package. -package loglevel +// Package loglevel_test has tests for level package. +package level import ( "github.com/dl1998/go-logging/internal/testutils" "testing" ) -// TestLogLevel_String tests that LogLevel correctly converts value to string. +// TestLogLevel_String tests that Level correctly converts value to string. func TestLogLevel_String(t *testing.T) { parameters := []struct { - input LogLevel + input Level expected string }{ {All, "all"}, @@ -32,7 +32,7 @@ func TestLogLevel_String(t *testing.T) { } } -// BenchmarkLogLevel_String performs benchmarking of the LogLevel.String(). +// BenchmarkLogLevel_String performs benchmarking of the Level.String(). func BenchmarkLogLevel_String(b *testing.B) { level := Debug @@ -41,11 +41,11 @@ func BenchmarkLogLevel_String(b *testing.B) { } } -// TestLogLevel_String tests that LogLevel returns correct digital representation +// TestLogLevel_String tests that Level returns correct digital representation // of the value. func TestLogLevel_DigitRepresentation(t *testing.T) { parameters := []struct { - input LogLevel + input Level expected int }{ {All, 0}, @@ -69,7 +69,7 @@ func TestLogLevel_DigitRepresentation(t *testing.T) { } // BenchmarkLogLevel_DigitRepresentation performs benchmarking of the -// LogLevel.DigitRepresentation(). +// Level.DigitRepresentation(). func BenchmarkLogLevel_DigitRepresentation(b *testing.B) { level := Debug @@ -78,11 +78,11 @@ func BenchmarkLogLevel_DigitRepresentation(b *testing.B) { } } -// TestLogLevel_Next tests that LogLevel returns next LogLevel. +// TestLogLevel_Next tests that Level returns next Level. func TestLogLevel_Next(t *testing.T) { parameters := []struct { - input LogLevel - expected LogLevel + input Level + expected Level }{ {All, Trace}, {Trace, Debug}, @@ -105,7 +105,7 @@ func TestLogLevel_Next(t *testing.T) { } } -// BenchmarkLogLevel_Next performs benchmarking of the LogLevel.Next(). +// BenchmarkLogLevel_Next performs benchmarking of the Level.Next(). func BenchmarkLogLevel_Next(b *testing.B) { level := Debug @@ -114,11 +114,11 @@ func BenchmarkLogLevel_Next(b *testing.B) { } } -// TestLogLevel_Previous tests that LogLevel returns previous LogLevel. +// TestLogLevel_Previous tests that Level returns previous Level. func TestLogLevel_Previous(t *testing.T) { parameters := []struct { - input LogLevel - expected LogLevel + input Level + expected Level }{ {All, All}, {Trace, All}, @@ -141,7 +141,7 @@ func TestLogLevel_Previous(t *testing.T) { } } -// BenchmarkLogLevel_Previous performs benchmarking of the LogLevel.Previous(). +// BenchmarkLogLevel_Previous performs benchmarking of the Level.Previous(). func BenchmarkLogLevel_Previous(b *testing.B) { level := Debug diff --git a/pkg/logger/logger.go b/pkg/logger/logger.go index 14d5883..a133c3f 100644 --- a/pkg/logger/logger.go +++ b/pkg/logger/logger.go @@ -4,12 +4,12 @@ package logger import ( "github.com/dl1998/go-logging/pkg/logger/formatter" "github.com/dl1998/go-logging/pkg/logger/handler" - "github.com/dl1998/go-logging/pkg/logger/loglevel" + "github.com/dl1998/go-logging/pkg/logger/level" ) var rootLogger *Logger -var fromLevel loglevel.LogLevel -var toLevel loglevel.LogLevel +var fromLevel level.Level +var toLevel level.Level var template string func init() { @@ -18,7 +18,7 @@ func init() { // baseLoggerInterface defines low level logging interface. type baseLoggerInterface interface { - Log(level loglevel.LogLevel, message string, parameters ...any) + Log(level level.Level, message string, parameters ...any) Name() string SetName(name string) Handlers() []handler.Interface @@ -32,8 +32,8 @@ type baseLogger struct { handlers []handler.Interface } -// Log logs interpolated message with the provided loglevel.LogLevel. -func (logger *baseLogger) Log(level loglevel.LogLevel, message string, parameters ...any) { +// Log logs interpolated message with the provided level.Level. +func (logger *baseLogger) Log(level level.Level, message string, parameters ...any) { for _, registeredHandler := range logger.handlers { registeredHandler.Write(logger.name, level, message, parameters...) } @@ -126,65 +126,65 @@ func (logger *Logger) RemoveHandler(handlerInterface handler.Interface) { logger.baseLogger.RemoveHandler(handlerInterface) } -// Trace logs a new message using Logger with loglevel.Trace level. +// Trace logs a new message using Logger with level.Trace level. func (logger *Logger) Trace(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Trace, message, parameters...) + logger.baseLogger.Log(level.Trace, message, parameters...) } -// Debug logs a new message using Logger with loglevel.Debug level. +// Debug logs a new message using Logger with level.Debug level. func (logger *Logger) Debug(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Debug, message, parameters...) + logger.baseLogger.Log(level.Debug, message, parameters...) } -// Verbose logs a new message using Logger with loglevel.Verbose level. +// Verbose logs a new message using Logger with level.Verbose level. func (logger *Logger) Verbose(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Verbose, message, parameters...) + logger.baseLogger.Log(level.Verbose, message, parameters...) } -// Info logs a new message using Logger with loglevel.Info level. +// Info logs a new message using Logger with level.Info level. func (logger *Logger) Info(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Info, message, parameters...) + logger.baseLogger.Log(level.Info, message, parameters...) } -// Notice logs a new message using Logger with loglevel.Notice level. +// Notice logs a new message using Logger with level.Notice level. func (logger *Logger) Notice(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Notice, message, parameters...) + logger.baseLogger.Log(level.Notice, message, parameters...) } -// Warning logs a new message using Logger with loglevel.Warning level. +// Warning logs a new message using Logger with level.Warning level. func (logger *Logger) Warning(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Warning, message, parameters...) + logger.baseLogger.Log(level.Warning, message, parameters...) } -// Severe logs a new message using Logger with loglevel.Severe level. +// Severe logs a new message using Logger with level.Severe level. func (logger *Logger) Severe(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Severe, message, parameters...) + logger.baseLogger.Log(level.Severe, message, parameters...) } -// Error logs a new message using Logger with loglevel.Error level. +// Error logs a new message using Logger with level.Error level. func (logger *Logger) Error(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Error, message, parameters...) + logger.baseLogger.Log(level.Error, message, parameters...) } -// Alert logs a new message using Logger with loglevel.Alert level. +// Alert logs a new message using Logger with level.Alert level. func (logger *Logger) Alert(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Alert, message, parameters...) + logger.baseLogger.Log(level.Alert, message, parameters...) } -// Critical logs a new message using Logger with loglevel.Critical level. +// Critical logs a new message using Logger with level.Critical level. func (logger *Logger) Critical(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Critical, message, parameters...) + logger.baseLogger.Log(level.Critical, message, parameters...) } -// Emergency logs a new message using Logger with loglevel.Emergency level. +// Emergency logs a new message using Logger with level.Emergency level. func (logger *Logger) Emergency(message string, parameters ...any) { - logger.baseLogger.Log(loglevel.Emergency, message, parameters...) + logger.baseLogger.Log(level.Emergency, message, parameters...) } // Configuration struct contains configuration for the logger. type Configuration struct { - fromLevel loglevel.LogLevel - toLevel loglevel.LogLevel + fromLevel level.Level + toLevel level.Level template string file string name string @@ -194,14 +194,14 @@ type Configuration struct { type Option func(*Configuration) // WithFromLevel sets fromLevel for the Configuration. -func WithFromLevel(fromLevel loglevel.LogLevel) Option { +func WithFromLevel(fromLevel level.Level) Option { return func(configuration *Configuration) { configuration.fromLevel = fromLevel } } // WithToLevel sets toLevel for the Configuration. -func WithToLevel(toLevel loglevel.LogLevel) Option { +func WithToLevel(toLevel level.Level) Option { return func(configuration *Configuration) { configuration.toLevel = toLevel } @@ -231,8 +231,8 @@ func WithName(name string) Option { // NewConfiguration creates a new instance of the Configuration. func NewConfiguration(options ...Option) *Configuration { newConfiguration := &Configuration{ - fromLevel: loglevel.Warning, - toLevel: loglevel.Null, + fromLevel: level.Warning, + toLevel: level.Null, template: "%(level):%(name):%(message)", file: "", name: "root", @@ -259,14 +259,14 @@ func Configure(configuration *Configuration) { defaultFormatter := formatter.New(configuration.template) - var createStdoutHandler = configuration.fromLevel.DigitRepresentation() <= loglevel.Severe.DigitRepresentation() - var createStderrHandler = configuration.toLevel.DigitRepresentation() >= loglevel.Error.DigitRepresentation() + var createStdoutHandler = configuration.fromLevel.DigitRepresentation() <= level.Severe.DigitRepresentation() + var createStderrHandler = configuration.toLevel.DigitRepresentation() >= level.Error.DigitRepresentation() var createFileHandler = configuration.file != "" if createStdoutHandler { stdoutToLevel := toLevel - if stdoutToLevel > loglevel.Severe { - stdoutToLevel = loglevel.Severe + if stdoutToLevel > level.Severe { + stdoutToLevel = level.Severe } newHandler := handler.NewConsoleHandler(configuration.fromLevel, stdoutToLevel, defaultFormatter) newLogger.baseLogger.AddHandler(newHandler) @@ -274,8 +274,8 @@ func Configure(configuration *Configuration) { if createStderrHandler { stderrFromLevel := fromLevel - if stderrFromLevel < loglevel.Error { - stderrFromLevel = loglevel.Error + if stderrFromLevel < level.Error { + stderrFromLevel = level.Error } newHandler := handler.NewConsoleErrorHandler(stderrFromLevel, configuration.toLevel, defaultFormatter) newLogger.baseLogger.AddHandler(newHandler) @@ -300,66 +300,66 @@ func Template() string { } // FromLevel returns fromLevel of the rootLogger. -func FromLevel() loglevel.LogLevel { +func FromLevel() level.Level { return fromLevel } // ToLevel returns toLevel of the rootLogger. -func ToLevel() loglevel.LogLevel { +func ToLevel() level.Level { return toLevel } -// Trace logs a new message using default logger with loglevel.Trace level. +// Trace logs a new message using default logger with level.Trace level. func Trace(message string, parameters ...any) { rootLogger.Trace(message, parameters...) } -// Debug logs a new message using default logger with loglevel.Debug level. +// Debug logs a new message using default logger with level.Debug level. func Debug(message string, parameters ...any) { rootLogger.Debug(message, parameters...) } -// Verbose logs a new message using default logger with loglevel.Verbose level. +// Verbose logs a new message using default logger with level.Verbose level. func Verbose(message string, parameters ...any) { rootLogger.Verbose(message, parameters...) } -// Info logs a new message using default logger with loglevel.Info level. +// Info logs a new message using default logger with level.Info level. func Info(message string, parameters ...any) { rootLogger.Info(message, parameters...) } -// Notice logs a new message using default logger with loglevel.Notice level. +// Notice logs a new message using default logger with level.Notice level. func Notice(message string, parameters ...any) { rootLogger.Notice(message, parameters...) } -// Warning logs a new message using default logger with loglevel.Warning level. +// Warning logs a new message using default logger with level.Warning level. func Warning(message string, parameters ...any) { rootLogger.Warning(message, parameters...) } -// Severe logs a new message using default logger with loglevel.Severe level. +// Severe logs a new message using default logger with level.Severe level. func Severe(message string, parameters ...any) { rootLogger.Severe(message, parameters...) } -// Error logs a new message using default logger with loglevel.Error level. +// Error logs a new message using default logger with level.Error level. func Error(message string, parameters ...any) { rootLogger.Error(message, parameters...) } -// Alert logs a new message using default logger with loglevel.Alert level. +// Alert logs a new message using default logger with level.Alert level. func Alert(message string, parameters ...any) { rootLogger.Alert(message, parameters...) } -// Critical logs a new message using default logger with loglevel.Critical level. +// Critical logs a new message using default logger with level.Critical level. func Critical(message string, parameters ...any) { rootLogger.Critical(message, parameters...) } -// Emergency logs a new message using default logger with loglevel.Emergency level. +// Emergency logs a new message using default logger with level.Emergency level. func Emergency(message string, parameters ...any) { rootLogger.Emergency(message, parameters...) } diff --git a/pkg/logger/logger_test.go b/pkg/logger/logger_test.go index 4cc9a35..e8b38db 100644 --- a/pkg/logger/logger_test.go +++ b/pkg/logger/logger_test.go @@ -5,7 +5,7 @@ import ( "github.com/dl1998/go-logging/internal/testutils" "github.com/dl1998/go-logging/pkg/logger/formatter" "github.com/dl1998/go-logging/pkg/logger/handler" - "github.com/dl1998/go-logging/pkg/logger/loglevel" + "github.com/dl1998/go-logging/pkg/logger/level" "io" "testing" ) @@ -29,7 +29,7 @@ type MockLogger struct { } // Log mocks Log from baseLogger. -func (mock *MockLogger) Log(level loglevel.LogLevel, message string, parameters ...any) { +func (mock *MockLogger) Log(level level.Level, message string, parameters ...any) { mock.CalledName = "Log" mock.Called = true mock.Parameters = append(make([]any, 0), level, message) @@ -103,17 +103,17 @@ func (mock *MockHandler) Writer() io.Writer { } // FromLevel mocks FromLevel from Handler. -func (mock *MockHandler) FromLevel() loglevel.LogLevel { +func (mock *MockHandler) FromLevel() level.Level { mock.CalledName = "FromLevel" mock.Called = true mock.Parameters = make([]any, 0) - returnValue := loglevel.Debug + returnValue := level.Debug mock.Return = returnValue return returnValue } // SetFromLevel mocks SetFromLevel from Handler. -func (mock *MockHandler) SetFromLevel(level loglevel.LogLevel) { +func (mock *MockHandler) SetFromLevel(level level.Level) { mock.CalledName = "SetFromLevel" mock.Called = true mock.Parameters = append(make([]any, 0), level) @@ -121,17 +121,17 @@ func (mock *MockHandler) SetFromLevel(level loglevel.LogLevel) { } // ToLevel mocks ToLevel from Handler. -func (mock *MockHandler) ToLevel() loglevel.LogLevel { +func (mock *MockHandler) ToLevel() level.Level { mock.CalledName = "ToLevel" mock.Called = true mock.Parameters = make([]any, 0) - returnValue := loglevel.Debug + returnValue := level.Debug mock.Return = returnValue return returnValue } // SetToLevel mocks SetToLevel from Handler. -func (mock *MockHandler) SetToLevel(level loglevel.LogLevel) { +func (mock *MockHandler) SetToLevel(level level.Level) { mock.CalledName = "SetToLevel" mock.Called = true mock.Parameters = append(make([]any, 0), level) @@ -149,7 +149,7 @@ func (mock *MockHandler) Formatter() formatter.Interface { } // Write mocks Write from Handler. -func (mock *MockHandler) Write(logName string, level loglevel.LogLevel, message string, parameters ...any) { +func (mock *MockHandler) Write(logName string, level level.Level, message string, parameters ...any) { mock.CalledName = "Write" mock.Called = true mock.Parameters = append(make([]any, 0), logName, level, message) @@ -168,12 +168,12 @@ func TestBaseLogger_Log(t *testing.T) { }, } - logLevel := loglevel.Debug + logLevel := level.Debug newBaseLogger.Log(logLevel, message, parameters...) testutils.AssertEquals(t, loggerName, newHandler.Parameters[0].(string)) - testutils.AssertEquals(t, logLevel, newHandler.Parameters[1].(loglevel.LogLevel)) + testutils.AssertEquals(t, logLevel, newHandler.Parameters[1].(level.Level)) testutils.AssertEquals(t, message, newHandler.Parameters[2].(string)) testutils.AssertEquals(t, parameters, newHandler.Parameters[3:len(newHandler.Parameters)]) } @@ -187,7 +187,7 @@ func BenchmarkBaseLogger_Log(b *testing.B) { }, } - logLevel := loglevel.Debug + logLevel := level.Debug for index := 0; index < b.N; index++ { newBaseLogger.Log(logLevel, message, parameters...) @@ -469,7 +469,7 @@ func TestLogger_Trace(t *testing.T) { newLogger.Trace(message, parameters...) - testutils.AssertEquals(t, loglevel.Trace, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Trace, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -494,7 +494,7 @@ func TestLogger_Debug(t *testing.T) { newLogger.Debug(message, parameters...) - testutils.AssertEquals(t, loglevel.Debug, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Debug, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -519,7 +519,7 @@ func TestLogger_Verbose(t *testing.T) { newLogger.Verbose(message, parameters...) - testutils.AssertEquals(t, loglevel.Verbose, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Verbose, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -544,7 +544,7 @@ func TestLogger_Info(t *testing.T) { newLogger.Info(message, parameters...) - testutils.AssertEquals(t, loglevel.Info, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Info, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -569,7 +569,7 @@ func TestLogger_Notice(t *testing.T) { newLogger.Notice(message, parameters...) - testutils.AssertEquals(t, loglevel.Notice, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Notice, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -594,7 +594,7 @@ func TestLogger_Warning(t *testing.T) { newLogger.Warning(message, parameters...) - testutils.AssertEquals(t, loglevel.Warning, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Warning, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -619,7 +619,7 @@ func TestLogger_Severe(t *testing.T) { newLogger.Severe(message, parameters...) - testutils.AssertEquals(t, loglevel.Severe, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Severe, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -644,7 +644,7 @@ func TestLogger_Error(t *testing.T) { newLogger.Error(message, parameters...) - testutils.AssertEquals(t, loglevel.Error, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Error, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -669,7 +669,7 @@ func TestLogger_Alert(t *testing.T) { newLogger.Alert(message, parameters...) - testutils.AssertEquals(t, loglevel.Alert, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Alert, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -694,7 +694,7 @@ func TestLogger_Critical(t *testing.T) { newLogger.Critical(message, parameters...) - testutils.AssertEquals(t, loglevel.Critical, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Critical, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -719,7 +719,7 @@ func TestLogger_Emergency(t *testing.T) { newLogger.Emergency(message, parameters...) - testutils.AssertEquals(t, loglevel.Emergency, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Emergency, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -739,18 +739,18 @@ func BenchmarkLogger_Emergency(b *testing.B) { func TestWithFromLevel(t *testing.T) { configuration := NewConfiguration() - option := WithFromLevel(loglevel.Trace) + option := WithFromLevel(level.Trace) option(configuration) - testutils.AssertEquals(t, configuration.fromLevel, loglevel.Trace) + testutils.AssertEquals(t, configuration.fromLevel, level.Trace) } // BenchmarkWithFromLevel perform benchmarking of the WithFromLevel(). func BenchmarkWithFromLevel(b *testing.B) { configuration := NewConfiguration() - option := WithFromLevel(loglevel.Trace) + option := WithFromLevel(level.Trace) for index := 0; index < b.N; index++ { option(configuration) @@ -761,18 +761,18 @@ func BenchmarkWithFromLevel(b *testing.B) { func TestWithToLevel(t *testing.T) { configuration := NewConfiguration() - option := WithToLevel(loglevel.Trace) + option := WithToLevel(level.Trace) option(configuration) - testutils.AssertEquals(t, configuration.toLevel, loglevel.Trace) + testutils.AssertEquals(t, configuration.toLevel, level.Trace) } // BenchmarkWithToLevel perform benchmarking of the WithToLevel(). func BenchmarkWithToLevel(b *testing.B) { configuration := NewConfiguration() - option := WithToLevel(loglevel.Trace) + option := WithToLevel(level.Trace) for index := 0; index < b.N; index++ { option(configuration) @@ -862,30 +862,30 @@ func BenchmarkWithName(b *testing.B) { func TestNewConfiguration(t *testing.T) { tests := map[string]struct { options []Option - expectedFromLevel loglevel.LogLevel - expectedToLevel loglevel.LogLevel + expectedFromLevel level.Level + expectedToLevel level.Level expectedTemplate string expectedFile string expectedName string }{ "Empty": { options: []Option{}, - expectedFromLevel: loglevel.Warning, - expectedToLevel: loglevel.Null, + expectedFromLevel: level.Warning, + expectedToLevel: level.Null, expectedTemplate: "%(level):%(name):%(message)", expectedFile: "", expectedName: "root", }, "Non Standard": { options: []Option{ - WithFromLevel(loglevel.All), - WithToLevel(loglevel.Emergency), + WithFromLevel(level.All), + WithToLevel(level.Emergency), WithTemplate("%(message):%(name):%(level)"), WithFile("file.log"), WithName("test"), }, - expectedFromLevel: loglevel.All, - expectedToLevel: loglevel.Emergency, + expectedFromLevel: level.All, + expectedToLevel: level.Emergency, expectedTemplate: "%(message):%(name):%(level)", expectedFile: "file.log", expectedName: "test", @@ -915,8 +915,8 @@ func BenchmarkNewConfiguration(b *testing.B) { // logger. func TestConfigure(t *testing.T) { configuration := NewConfiguration( - WithFromLevel(loglevel.All), - WithToLevel(loglevel.Emergency), + WithFromLevel(level.All), + WithToLevel(level.Emergency), WithTemplate("%(message):%(name):%(level)"), WithFile(""), WithName("test"), @@ -938,8 +938,8 @@ func TestConfigure_IncorrectLevels(t *testing.T) { }() configuration := NewConfiguration( - WithFromLevel(loglevel.Warning), - WithToLevel(loglevel.Debug), + WithFromLevel(level.Warning), + WithToLevel(level.Debug), ) Configure(configuration) @@ -948,8 +948,8 @@ func TestConfigure_IncorrectLevels(t *testing.T) { // BenchmarkConfigure perform benchmarking of the Configure(). func BenchmarkConfigure(b *testing.B) { configuration := NewConfiguration( - WithFromLevel(loglevel.All), - WithToLevel(loglevel.Emergency), + WithFromLevel(level.All), + WithToLevel(level.Emergency), WithTemplate("%(message):%(name):%(level)"), WithFile(""), WithName("test"), @@ -996,7 +996,7 @@ func BenchmarkTemplate(b *testing.B) { func TestFromLevel(t *testing.T) { Configure(NewConfiguration()) - testutils.AssertEquals(t, loglevel.Warning, FromLevel()) + testutils.AssertEquals(t, level.Warning, FromLevel()) } // BenchmarkFromLevel perform benchmarking of the FromLevel(). @@ -1012,7 +1012,7 @@ func BenchmarkFromLevel(b *testing.B) { func TestToLevel(t *testing.T) { Configure(NewConfiguration()) - testutils.AssertEquals(t, loglevel.Null, ToLevel()) + testutils.AssertEquals(t, level.Null, ToLevel()) } // BenchmarkToLevel perform benchmarking of the ToLevel(). @@ -1033,7 +1033,7 @@ func TestTrace(t *testing.T) { Trace(message, parameters...) - testutils.AssertEquals(t, loglevel.Trace, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Trace, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -1058,7 +1058,7 @@ func TestDebug(t *testing.T) { Debug(message, parameters...) - testutils.AssertEquals(t, loglevel.Debug, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Debug, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -1083,7 +1083,7 @@ func TestVerbose(t *testing.T) { Verbose(message, parameters...) - testutils.AssertEquals(t, loglevel.Verbose, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Verbose, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -1108,7 +1108,7 @@ func TestInfo(t *testing.T) { Info(message, parameters...) - testutils.AssertEquals(t, loglevel.Info, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Info, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -1133,7 +1133,7 @@ func TestNotice(t *testing.T) { Notice(message, parameters...) - testutils.AssertEquals(t, loglevel.Notice, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Notice, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -1158,7 +1158,7 @@ func TestWarning(t *testing.T) { Warning(message, parameters...) - testutils.AssertEquals(t, loglevel.Warning, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Warning, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -1183,7 +1183,7 @@ func TestSevere(t *testing.T) { Severe(message, parameters...) - testutils.AssertEquals(t, loglevel.Severe, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Severe, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -1208,7 +1208,7 @@ func TestError(t *testing.T) { Error(message, parameters...) - testutils.AssertEquals(t, loglevel.Error, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Error, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -1233,7 +1233,7 @@ func TestAlert(t *testing.T) { Alert(message, parameters...) - testutils.AssertEquals(t, loglevel.Alert, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Alert, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -1258,7 +1258,7 @@ func TestCritical(t *testing.T) { Critical(message, parameters...) - testutils.AssertEquals(t, loglevel.Critical, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Critical, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } @@ -1283,7 +1283,7 @@ func TestEmergency(t *testing.T) { Emergency(message, parameters...) - testutils.AssertEquals(t, loglevel.Emergency, mockLogger.Parameters[0].(loglevel.LogLevel)) + testutils.AssertEquals(t, level.Emergency, mockLogger.Parameters[0].(level.Level)) testutils.AssertEquals(t, message, mockLogger.Parameters[1].(string)) testutils.AssertEquals(t, parameters, mockLogger.Parameters[2:len(mockLogger.Parameters)]) } diff --git a/pkg/logger/loglevel/loglevel.go b/pkg/logger/loglevel/loglevel.go deleted file mode 100644 index cffa8d7..0000000 --- a/pkg/logger/loglevel/loglevel.go +++ /dev/null @@ -1,63 +0,0 @@ -// Package loglevel contains LogLevel definition with supported levels. -package loglevel - -type LogLevel int - -const step = 5 - -const ( - All = LogLevel(iota * step) - Trace - Debug - Verbose - Info - Notice - Warning - Severe - Error - Alert - Critical - Emergency - Null -) - -// String returns string representation of the LogLevel. -func (level LogLevel) String() string { - mapping := map[LogLevel]string{ - All: "all", - Trace: "trace", - Debug: "debug", - Verbose: "verbose", - Info: "info", - Notice: "notice", - Warning: "warning", - Severe: "severe", - Error: "error", - Alert: "alert", - Critical: "critical", - Emergency: "emergency", - Null: "null", - } - return mapping[level] -} - -// DigitRepresentation returns digit representations of the LogLevel. -func (level LogLevel) DigitRepresentation() int { - return int(level) -} - -// Next returns next LogLevel. -func (level LogLevel) Next() LogLevel { - if level == Null { - return level - } - return LogLevel(level.DigitRepresentation() + step) -} - -// Previous returns previous LogLevel. -func (level LogLevel) Previous() LogLevel { - if level == All { - return level - } - return LogLevel(level.DigitRepresentation() - step) -}