logrus/logger.go

348 lines
8.3 KiB
Go
Raw Normal View History

2014-02-24 04:50:42 +04:00
package logrus
import (
"io"
"os"
"sync"
"sync/atomic"
2014-02-24 04:50:42 +04:00
)
type Logger struct {
2014-03-12 18:34:29 +04:00
// The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
2015-08-07 11:56:08 +03:00
// file, or leave it default which is `os.Stderr`. You can also set this to
2014-03-12 18:34:29 +04:00
// something more adventorous, such as logging to Kafka.
Out io.Writer
// Hooks for the logger instance. These allow firing events based on logging
// levels and log entries. For example, to send errors to an error tracking
// service, log to StatsD or dump the core on fatal errors.
2015-06-26 18:42:49 +03:00
Hooks LevelHooks
2014-03-12 18:34:29 +04:00
// All log entries pass through the formatter before logged to Out. The
// included formatters are `TextFormatter` and `JSONFormatter` for which
// TextFormatter is the default. In development (when a TTY is attached) it
// logs with colors, but to a file it wouldn't. You can easily implement your
// own that implements the `Formatter` interface, see the `README` or included
// formatters for examples.
2014-03-11 03:22:08 +04:00
Formatter Formatter
2014-03-12 18:34:29 +04:00
// The logging level the logger should log at. This is typically (and defaults
// to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
// logged.
2014-03-12 18:34:29 +04:00
Level Level
// Used to sync writing to the log. Locking is enabled by Default
mu MutexWrap
2016-06-18 23:08:25 +03:00
// Reusable empty entry
entryPool sync.Pool
}
type MutexWrap struct {
lock sync.Mutex
disabled bool
}
func (mw *MutexWrap) Lock() {
if !mw.disabled {
mw.lock.Lock()
}
}
func (mw *MutexWrap) Unlock() {
if !mw.disabled {
mw.lock.Unlock()
}
}
func (mw *MutexWrap) Disable() {
mw.disabled = true
2014-03-12 18:34:29 +04:00
}
// Creates a new logger. Configuration should be set by changing `Formatter`,
// `Out` and `Hooks` directly on the default logger instance. You can also just
// instantiate your own:
//
// var log = &Logger{
// Out: os.Stderr,
// Formatter: new(JSONFormatter),
2015-06-26 18:42:49 +03:00
// Hooks: make(LevelHooks),
2014-11-27 09:54:16 +03:00
// Level: logrus.DebugLevel,
2014-03-12 18:34:29 +04:00
// }
//
// It's recommended to make this a global instance called `log`.
2014-02-24 04:50:42 +04:00
func New() *Logger {
return &Logger{
2015-04-22 22:27:44 +03:00
Out: os.Stderr,
2014-03-11 03:22:08 +04:00
Formatter: new(TextFormatter),
2015-06-26 18:42:49 +03:00
Hooks: make(LevelHooks),
Level: InfoLevel,
2014-02-24 04:50:42 +04:00
}
}
2016-06-18 23:08:25 +03:00
func (logger *Logger) newEntry() *Entry {
entry, ok := logger.entryPool.Get().(*Entry)
if ok {
return entry
}
return NewEntry(logger)
}
func (logger *Logger) releaseEntry(entry *Entry) {
logger.entryPool.Put(entry)
}
2016-05-06 06:48:51 +03:00
// Adds a field to the log entry, note that it doesn't log until you call
2014-03-12 18:34:29 +04:00
// Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry.
2015-08-20 07:07:28 +03:00
// If you want multiple fields, use `WithFields`.
2014-02-24 04:50:42 +04:00
func (logger *Logger) WithField(key string, value interface{}) *Entry {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
defer logger.releaseEntry(entry)
return entry.WithField(key, value)
2014-02-24 04:50:42 +04:00
}
2014-03-12 18:34:29 +04:00
// Adds a struct of fields to the log entry. All it does is call `WithField` for
// each `Field`.
2014-02-24 04:50:42 +04:00
func (logger *Logger) WithFields(fields Fields) *Entry {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
defer logger.releaseEntry(entry)
return entry.WithFields(fields)
2014-02-24 04:50:42 +04:00
}
// Add an error as single field to the log entry. All it does is call
// `WithError` for the given `error`.
func (logger *Logger) WithError(err error) *Entry {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
defer logger.releaseEntry(entry)
return entry.WithError(err)
}
2014-02-24 04:50:42 +04:00
func (logger *Logger) Debugf(format string, args ...interface{}) {
if logger.IsDebugEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Debugf(format, args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Infof(format string, args ...interface{}) {
if logger.IsInfoEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Infof(format, args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Printf(format string, args ...interface{}) {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Printf(format, args...)
logger.releaseEntry(entry)
2014-02-24 04:50:42 +04:00
}
2014-03-11 03:22:08 +04:00
func (logger *Logger) Warnf(format string, args ...interface{}) {
if logger.IsWarnEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Warnf(format, args...)
logger.releaseEntry(entry)
}
2014-03-11 03:22:08 +04:00
}
2014-02-24 04:50:42 +04:00
func (logger *Logger) Warningf(format string, args ...interface{}) {
if logger.IsWarnEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Warnf(format, args...)
logger.releaseEntry(entry)
}
2014-03-11 03:22:08 +04:00
}
func (logger *Logger) Errorf(format string, args ...interface{}) {
if logger.IsErrorEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Errorf(format, args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Fatalf(format string, args ...interface{}) {
if logger.IsFatalEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Fatalf(format, args...)
logger.releaseEntry(entry)
}
Exit(1)
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Panicf(format string, args ...interface{}) {
if logger.IsPanicEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Panicf(format, args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Debug(args ...interface{}) {
if logger.IsDebugEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Debug(args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Info(args ...interface{}) {
if logger.IsInfoEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Info(args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Print(args ...interface{}) {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Info(args...)
logger.releaseEntry(entry)
2014-02-24 04:50:42 +04:00
}
2014-03-11 03:22:08 +04:00
func (logger *Logger) Warn(args ...interface{}) {
if logger.IsWarnEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Warn(args...)
logger.releaseEntry(entry)
}
2014-03-11 03:22:08 +04:00
}
2014-02-24 04:50:42 +04:00
func (logger *Logger) Warning(args ...interface{}) {
if logger.IsWarnEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Warn(args...)
logger.releaseEntry(entry)
}
2014-03-11 03:22:08 +04:00
}
func (logger *Logger) Error(args ...interface{}) {
if logger.IsErrorEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Error(args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Fatal(args ...interface{}) {
if logger.IsFatalEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Fatal(args...)
logger.releaseEntry(entry)
}
Exit(1)
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Panic(args ...interface{}) {
if logger.IsPanicEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Panic(args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Debugln(args ...interface{}) {
if logger.IsDebugEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Debugln(args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Infoln(args ...interface{}) {
if logger.IsInfoEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Infoln(args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Println(args ...interface{}) {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Println(args...)
logger.releaseEntry(entry)
2014-02-24 04:50:42 +04:00
}
2014-03-11 03:22:08 +04:00
func (logger *Logger) Warnln(args ...interface{}) {
if logger.IsWarnEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Warnln(args...)
logger.releaseEntry(entry)
}
2014-03-11 03:22:08 +04:00
}
2014-02-24 04:50:42 +04:00
func (logger *Logger) Warningln(args ...interface{}) {
if logger.IsWarnEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Warnln(args...)
logger.releaseEntry(entry)
}
2014-03-11 03:22:08 +04:00
}
func (logger *Logger) Errorln(args ...interface{}) {
if logger.IsErrorEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Errorln(args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Fatalln(args ...interface{}) {
if logger.IsFatalEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Fatalln(args...)
logger.releaseEntry(entry)
}
Exit(1)
2014-02-24 04:50:42 +04:00
}
func (logger *Logger) Panicln(args ...interface{}) {
if logger.IsPanicEnabled() {
2016-06-18 23:08:25 +03:00
entry := logger.newEntry()
entry.Panicln(args...)
logger.releaseEntry(entry)
}
2014-02-24 04:50:42 +04:00
}
//When file is opened with appending mode, it's safe to
//write concurrently to a file (within 4k message on Linux).
//In these cases user can choose to disable the lock.
func (logger *Logger) SetNoLock() {
logger.mu.Disable()
}
func (logger *Logger) level() Level {
return Level(atomic.LoadUint32((*uint32)(&logger.Level)))
}
func (logger *Logger) SetLevel(level Level) {
atomic.StoreUint32((*uint32)(&logger.Level), uint32(level))
}
2017-08-04 18:24:22 +03:00
func (logger *Logger) AddHook(hook Hook) {
logger.mu.Lock()
defer logger.mu.Unlock()
logger.Hooks.Add(hook)
}
func (logger *Logger) IsDebugEnabled() bool {
return logger.level() >= DebugLevel
}
func (logger *Logger) IsInfoEnabled() bool {
return logger.level() >= InfoLevel
}
func (logger *Logger) IsWarnEnabled() bool {
return logger.level() >= WarnLevel
}
func (logger *Logger) IsErrorEnabled() bool {
return logger.level() >= ErrorLevel
}
func (logger *Logger) IsFatalEnabled() bool {
return logger.level() >= FatalLevel
}
func (logger *Logger) IsPanicEnabled() bool {
return logger.level() >= PanicLevel
}