1 // Copyright 2020 Tymoteusz Blazejczyk 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 package logger 16 17 import ( 18 "os" 19 "sync" 20 ) 21 22 var gOnce sync.Once // nolint:gochecknoglobals 23 var gInstance *Logger // nolint:gochecknoglobals 24 25 // Get returns global logger instance. 26 func Get() *Logger { 27 gOnce.Do(func() { 28 gInstance = New() 29 }) 30 31 return gInstance 32 } 33 34 // Enable enables all added log handlers. 35 func Enable() *Logger { 36 return Get().Enable() 37 } 38 39 // Disable disabled all added log handlers. 40 func Disable() *Logger { 41 return Get().Disable() 42 } 43 44 // IsEnabled returns true if at least one of added log handlers is enabled. 45 func IsEnabled() bool { 46 return Get().IsEnabled() 47 } 48 49 // SetLevel sets log level to all added log handlers. 50 func SetLevel(level int) *Logger { 51 return Get().SetLevel(level) 52 } 53 54 // SetMinimumLevel sets minimum log level to all added log handlers. 55 func SetMinimumLevel(level int) *Logger { 56 return Get().SetMinimumLevel(level) 57 } 58 59 // SetMaximumLevel sets maximum log level to all added log handlers. 60 func SetMaximumLevel(level int) *Logger { 61 return Get().SetMaximumLevel(level) 62 } 63 64 // SetLevelRange sets minimum and maximum log level values to all added log handlers. 65 func SetLevelRange(min, max int) *Logger { 66 return Get().SetLevelRange(min, max) 67 } 68 69 // SetFormatter sets provided formatter to all added log handlers. 70 func SetFormatter(formatter *Formatter) *Logger { 71 return Get().SetFormatter(formatter) 72 } 73 74 // SetFormat sets provided format string to all added log handlers. 75 func SetFormat(format string) *Logger { 76 return Get().SetFormat(format) 77 } 78 79 // SetDateFormat sets provided date format string to all added log handlers. 80 func SetDateFormat(format string) *Logger { 81 return Get().SetDateFormat(format) 82 } 83 84 // SetPlaceholder sets provided placeholder string to all added log handlers. 85 func SetPlaceholder(placeholder string) *Logger { 86 return Get().SetPlaceholder(placeholder) 87 } 88 89 // AddFuncs adds template functions to format log message to all added log handlers. 90 func AddFuncs(funcs FormatterFuncs) *Logger { 91 return Get().AddFuncs(funcs) 92 } 93 94 // ResetFormatters resets all formatters from added log handlers. 95 func ResetFormatters() *Logger { 96 return Get().ResetFormatters() 97 } 98 99 // SetErrorCode sets error code that is returned during Fatal call. 100 // On default it is 1. 101 func SetErrorCode(errorCode int) *Logger { 102 return Get().SetErrorCode(errorCode) 103 } 104 105 // GetErrorCode returns error code. 106 func GetErrorCode() int { 107 return Get().GetErrorCode() 108 } 109 110 // SetName sets logger name. 111 func SetName(name string) *Logger { 112 return Get().SetName(name) 113 } 114 115 // GetName returns logger name. 116 func GetName() string { 117 return Get().GetName() 118 } 119 120 // AddHandler sets log handler under provided identifier name. 121 func AddHandler(name string, handler Handler) *Logger { 122 return Get().AddHandler(name, handler) 123 } 124 125 // SetHandler sets a single log handler for logger. It is equivalent to 126 // logger.RemoveHandlers().SetHandlers(logger.Handlers{name: handler}). 127 func SetHandler(name string, handler Handler) *Logger { 128 return Get().SetHandler(name, handler) 129 } 130 131 // SetHandlers sets log handlers for logger. 132 func SetHandlers(handlers Handlers) *Logger { 133 return Get().SetHandlers(handlers) 134 } 135 136 // GetHandler returns added log handler by provided name. 137 func GetHandler(name string) (Handler, error) { 138 return Get().GetHandler(name) 139 } 140 141 // GetHandlers returns all added log handlers. 142 func GetHandlers() Handlers { 143 return Get().GetHandlers() 144 } 145 146 // RemoveHandler removes added log handler by provided name. 147 func RemoveHandler(name string) *Logger { 148 return Get().RemoveHandler(name) 149 } 150 151 // RemoveHandlers removes all added log handlers. 152 func RemoveHandlers() *Logger { 153 return Get().RemoveHandlers() 154 } 155 156 // ResetHandlers sets logger default log handlers. 157 func ResetHandlers() *Logger { 158 return Get().ResetHandlers() 159 } 160 161 // Reset resets logger to default state and default log handlers. 162 func Reset() *Logger { 163 return Get().ResetHandlers() 164 } 165 166 // SetIDGenerator sets ID generator function that is called by logger to 167 // generate ID for created log messages. 168 func SetIDGenerator(idGenerator IDGenerator) *Logger { 169 return Get().SetIDGenerator(idGenerator) 170 } 171 172 // GetIDGenerator returns ID generator function that is called by logger to 173 // generate ID for created log messages. 174 func GetIDGenerator() IDGenerator { 175 return Get().GetIDGenerator() 176 } 177 178 // Trace logs finer-grained informational messages than the Debug. It creates 179 // and sends lightweight not formatted log messages to separate running logger 180 // thread for further formatting and I/O handling from different added log 181 // handlers. 182 func Trace(message string, arguments ...interface{}) { 183 Get().LogMessage(TraceLevel, TraceName, message, arguments...) 184 } 185 186 // Debug logs debugging messages. It creates and sends lightweight not formatted 187 // log messages to separate running logger thread for further formatting and 188 // I/O handling from different added log handlers. 189 func Debug(message string, arguments ...interface{}) { 190 Get().LogMessage(DebugLevel, DebugName, message, arguments...) 191 } 192 193 // Info logs informational messages. It creates and sends lightweight not 194 // formatted log messages to separate running logger thread for further 195 // formatting and I/O handling from different added log handlers. 196 func Info(message string, arguments ...interface{}) { 197 Get().LogMessage(InfoLevel, InfoName, message, arguments...) 198 } 199 200 // Notice logs messages for significant conditions. It creates and sends 201 // lightweight not formatted log messages to separate running logger thread for 202 // further formatting and I/O handling from different added log handlers. 203 func Notice(message string, arguments ...interface{}) { 204 Get().LogMessage(NoticeLevel, NoticeName, message, arguments...) 205 } 206 207 // Warning logs messages for warning conditions that can be potentially harmful. 208 // It creates and sends lightweight not formatted log messages to separate 209 // running logger thread for further formatting and I/O handling from different 210 // added log handlers. 211 func Warning(message string, arguments ...interface{}) { 212 Get().LogMessage(WarningLevel, WarningName, message, arguments...) 213 } 214 215 // Error logs messages for error conditions. It creates and sends lightweight 216 // not formatted log messages to separate running logger thread for further 217 // formatting and I/O handling from different added log handlers. 218 func Error(message string, arguments ...interface{}) { 219 Get().LogMessage(ErrorLevel, ErrorName, message, arguments...) 220 } 221 222 // Critical logs messages for critical conditions. It creates and sends 223 // lightweight not formatted log messages to separate running logger thread for 224 // further formatting and I/O handling from different added log handlers. 225 func Critical(message string, arguments ...interface{}) { 226 Get().LogMessage(CriticalLevel, CriticalName, message, arguments...) 227 } 228 229 // Alert logs messages for alert conditions. It creates and sends lightweight 230 // not formatted log messages to separate running logger thread for further 231 // formatting and I/O handling from different added log handlers. 232 func Alert(message string, arguments ...interface{}) { 233 Get().LogMessage(AlertLevel, AlertName, message, arguments...) 234 } 235 236 // Fatal logs messages for fatal conditions. It stops logger worker thread and 237 // it exists the application with an error code. It creates and sends 238 // lightweight not formatted log messages to separate running logger thread for 239 // further formatting and I/O handling from different added log handlers. 240 func Fatal(message string, arguments ...interface{}) { 241 Get().LogMessage(FatalLevel, FatalName, message, arguments...) 242 Close() 243 os.Exit(Get().GetErrorCode()) // revive:disable-line 244 } 245 246 // Panic logs messages for fatal conditions. It stops logger worker thread and 247 // it exists the application with a panic. It creates and sends lightweight not 248 // formatted log messages to separate running logger thread for further 249 // formatting and I/O handling from different added log handlers. 250 func Panic(message string, arguments ...interface{}) { 251 Get().LogMessage(PanicLevel, PanicName, message, arguments...) 252 Close() 253 panic(NewRuntimeError("Panic error")) 254 } 255 256 // Log logs messages with user defined log level value and name. It creates and 257 // sends lightweight not formatted log messages to separate running logger 258 // thread for further formatting and I/O handling from different added log 259 // handlers. 260 func Log(level int, levelName, message string, arguments ...interface{}) { 261 Get().LogMessage(level, levelName, message, arguments...) 262 } 263 264 // Emit emits provided log record to logger worker thread for further 265 // formatting and I/O handling from different addded log handlers. 266 func Emit(record *Record) *Logger { 267 return Get().Emit(record) 268 } 269 270 // Flush flushes all log messages. 271 func Flush() *Logger { 272 return Get().Flush() 273 } 274 275 // Close closes all added log handlers. 276 func Close() { 277 err := Get().Close() 278 279 if err != nil { 280 printError(NewRuntimeError("cannot close logger")) 281 } 282 } 283