...

Source file src/gitlab.com/tymonx/go-logger/logger/glogger.go

Documentation: gitlab.com/tymonx/go-logger/logger

     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  

View as plain text