2014-10-14 17:35:10 +00:00
|
|
|
/*
|
|
|
|
Package ethlog implements a multi-output leveled logger.
|
|
|
|
|
2014-10-15 09:15:59 +00:00
|
|
|
Other packages use tagged logger to send log messages to shared
|
|
|
|
(process-wide) logging engine. The shared logging engine dispatches to
|
|
|
|
multiple log systems. The log level can be set separately per log
|
|
|
|
system.
|
2014-10-14 17:35:10 +00:00
|
|
|
|
2014-10-15 09:15:59 +00:00
|
|
|
Logging is asynchrounous and does not block the caller. Message
|
2014-10-14 17:35:10 +00:00
|
|
|
formatting is performed by the caller goroutine to avoid incorrect
|
|
|
|
logging of mutable state.
|
|
|
|
*/
|
2014-06-23 11:49:04 +00:00
|
|
|
package ethlog
|
|
|
|
|
|
|
|
import (
|
2014-06-26 17:45:57 +00:00
|
|
|
"fmt"
|
|
|
|
"io"
|
|
|
|
"log"
|
|
|
|
"os"
|
|
|
|
"sync"
|
2014-10-14 12:35:54 +00:00
|
|
|
"sync/atomic"
|
2014-06-23 11:49:04 +00:00
|
|
|
)
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// LogSystem is implemented by log output devices.
|
|
|
|
// All methods can be called concurrently from multiple goroutines.
|
2014-06-23 11:49:04 +00:00
|
|
|
type LogSystem interface {
|
2014-06-26 17:45:57 +00:00
|
|
|
GetLogLevel() LogLevel
|
|
|
|
SetLogLevel(i LogLevel)
|
|
|
|
Println(v ...interface{})
|
|
|
|
Printf(format string, v ...interface{})
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type logMessage struct {
|
2014-06-26 17:45:57 +00:00
|
|
|
LogLevel LogLevel
|
|
|
|
format bool
|
|
|
|
msg string
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-06-26 17:45:57 +00:00
|
|
|
func newPrintlnLogMessage(level LogLevel, tag string, v ...interface{}) *logMessage {
|
|
|
|
return &logMessage{level, false, fmt.Sprintf("[%s] %s", tag, fmt.Sprint(v...))}
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-06-26 17:45:57 +00:00
|
|
|
func newPrintfLogMessage(level LogLevel, tag string, format string, v ...interface{}) *logMessage {
|
|
|
|
return &logMessage{level, true, fmt.Sprintf("[%s] %s", tag, fmt.Sprintf(format, v...))}
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type LogLevel uint8
|
|
|
|
|
|
|
|
const (
|
2014-10-14 17:35:10 +00:00
|
|
|
// Standard log levels
|
2014-06-26 17:45:57 +00:00
|
|
|
Silence LogLevel = iota
|
|
|
|
ErrorLevel
|
|
|
|
WarnLevel
|
|
|
|
InfoLevel
|
|
|
|
DebugLevel
|
|
|
|
DebugDetailLevel
|
2014-06-23 11:49:04 +00:00
|
|
|
)
|
|
|
|
|
2014-10-14 12:29:04 +00:00
|
|
|
var (
|
|
|
|
mutex sync.RWMutex // protects logSystems
|
|
|
|
logSystems []LogSystem
|
|
|
|
|
|
|
|
logMessages = make(chan *logMessage)
|
|
|
|
drainWaitReq = make(chan chan struct{})
|
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
go dispatchLoop()
|
2014-07-14 17:37:01 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 12:29:04 +00:00
|
|
|
func dispatchLoop() {
|
|
|
|
var drainWait []chan struct{}
|
|
|
|
dispatchDone := make(chan struct{})
|
|
|
|
pending := 0
|
2014-06-26 17:45:57 +00:00
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case msg := <-logMessages:
|
2014-10-14 12:29:04 +00:00
|
|
|
go dispatch(msg, dispatchDone)
|
|
|
|
pending++
|
|
|
|
case waiter := <-drainWaitReq:
|
|
|
|
if pending == 0 {
|
|
|
|
close(waiter)
|
|
|
|
} else {
|
|
|
|
drainWait = append(drainWait, waiter)
|
|
|
|
}
|
|
|
|
case <-dispatchDone:
|
|
|
|
pending--
|
|
|
|
if pending == 0 {
|
|
|
|
for _, c := range drainWait {
|
|
|
|
close(c)
|
|
|
|
}
|
|
|
|
drainWait = nil
|
|
|
|
}
|
2014-06-26 17:45:57 +00:00
|
|
|
}
|
|
|
|
}
|
2014-07-14 17:37:01 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 12:29:04 +00:00
|
|
|
func dispatch(msg *logMessage, done chan<- struct{}) {
|
|
|
|
mutex.RLock()
|
|
|
|
for _, sys := range logSystems {
|
|
|
|
if sys.GetLogLevel() >= msg.LogLevel {
|
|
|
|
if msg.format {
|
|
|
|
sys.Printf(msg.msg)
|
|
|
|
} else {
|
|
|
|
sys.Println(msg.msg)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex.RUnlock()
|
|
|
|
done <- struct{}{}
|
|
|
|
}
|
|
|
|
|
|
|
|
// send delivers a message to all installed log
|
|
|
|
// systems. it doesn't wait for the message to be
|
|
|
|
// written.
|
2014-07-14 17:37:01 +00:00
|
|
|
func send(msg *logMessage) {
|
|
|
|
logMessages <- msg
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Reset removes all active log systems.
|
2014-07-05 17:36:22 +00:00
|
|
|
func Reset() {
|
|
|
|
mutex.Lock()
|
2014-10-14 12:29:04 +00:00
|
|
|
logSystems = nil
|
|
|
|
mutex.Unlock()
|
2014-07-05 17:36:22 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 12:29:04 +00:00
|
|
|
// Flush waits until all current log messages have been dispatched to
|
|
|
|
// the active log systems.
|
2014-07-05 17:36:22 +00:00
|
|
|
func Flush() {
|
2014-10-14 12:29:04 +00:00
|
|
|
waiter := make(chan struct{})
|
|
|
|
drainWaitReq <- waiter
|
|
|
|
<-waiter
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// AddLogSystem starts printing messages to the given LogSystem.
|
|
|
|
func AddLogSystem(logSystem LogSystem) {
|
|
|
|
mutex.Lock()
|
|
|
|
logSystems = append(logSystems, logSystem)
|
|
|
|
mutex.Unlock()
|
|
|
|
}
|
|
|
|
|
2014-10-15 09:15:59 +00:00
|
|
|
// A Logger prints messages prefixed by a given tag. It provides named
|
|
|
|
// Printf and Println style methods for all loglevels. Each ethereum
|
|
|
|
// component should have its own logger with a unique prefix.
|
2014-06-23 11:49:04 +00:00
|
|
|
type Logger struct {
|
2014-06-26 17:45:57 +00:00
|
|
|
tag string
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewLogger(tag string) *Logger {
|
2014-06-26 17:45:57 +00:00
|
|
|
return &Logger{tag}
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) sendln(level LogLevel, v ...interface{}) {
|
2014-07-07 08:59:16 +00:00
|
|
|
if logMessages != nil {
|
|
|
|
msg := newPrintlnLogMessage(level, logger.tag, v...)
|
2014-07-14 18:02:34 +00:00
|
|
|
send(msg)
|
2014-06-26 17:45:57 +00:00
|
|
|
}
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) sendf(level LogLevel, format string, v ...interface{}) {
|
2014-07-07 08:59:16 +00:00
|
|
|
if logMessages != nil {
|
|
|
|
msg := newPrintfLogMessage(level, logger.tag, format, v...)
|
2014-07-14 18:02:34 +00:00
|
|
|
send(msg)
|
2014-06-26 17:45:57 +00:00
|
|
|
}
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Errorln writes a message with ErrorLevel.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) Errorln(v ...interface{}) {
|
|
|
|
logger.sendln(ErrorLevel, v...)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Warnln writes a message with WarnLevel.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) Warnln(v ...interface{}) {
|
|
|
|
logger.sendln(WarnLevel, v...)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Infoln writes a message with InfoLevel.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) Infoln(v ...interface{}) {
|
|
|
|
logger.sendln(InfoLevel, v...)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Debugln writes a message with DebugLevel.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) Debugln(v ...interface{}) {
|
|
|
|
logger.sendln(DebugLevel, v...)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// DebugDetailln writes a message with DebugDetailLevel.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) DebugDetailln(v ...interface{}) {
|
|
|
|
logger.sendln(DebugDetailLevel, v...)
|
2014-06-25 15:37:38 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Errorf writes a message with ErrorLevel.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) Errorf(format string, v ...interface{}) {
|
|
|
|
logger.sendf(ErrorLevel, format, v...)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Warnf writes a message with WarnLevel.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) Warnf(format string, v ...interface{}) {
|
|
|
|
logger.sendf(WarnLevel, format, v...)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Infof writes a message with InfoLevel.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) Infof(format string, v ...interface{}) {
|
|
|
|
logger.sendf(InfoLevel, format, v...)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Debugf writes a message with DebugLevel.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) Debugf(format string, v ...interface{}) {
|
|
|
|
logger.sendf(DebugLevel, format, v...)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// DebugDetailf writes a message with DebugDetailLevel.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) DebugDetailf(format string, v ...interface{}) {
|
|
|
|
logger.sendf(DebugDetailLevel, format, v...)
|
2014-06-25 15:37:38 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Fatalln writes a message with ErrorLevel and exits the program.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) Fatalln(v ...interface{}) {
|
|
|
|
logger.sendln(ErrorLevel, v...)
|
|
|
|
Flush()
|
|
|
|
os.Exit(0)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// Fatalf writes a message with ErrorLevel and exits the program.
|
2014-06-26 17:45:57 +00:00
|
|
|
func (logger *Logger) Fatalf(format string, v ...interface{}) {
|
|
|
|
logger.sendf(ErrorLevel, format, v...)
|
|
|
|
Flush()
|
|
|
|
os.Exit(0)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
// NewStdLogSystem creates a LogSystem that prints to the given writer.
|
|
|
|
// The flag values are defined package log.
|
|
|
|
func NewStdLogSystem(writer io.Writer, flags int, level LogLevel) LogSystem {
|
|
|
|
logger := log.New(writer, "", flags)
|
|
|
|
return &stdLogSystem{logger, uint32(level)}
|
|
|
|
}
|
|
|
|
|
|
|
|
type stdLogSystem struct {
|
2014-06-26 17:45:57 +00:00
|
|
|
logger *log.Logger
|
2014-10-14 12:35:54 +00:00
|
|
|
level uint32
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
func (t *stdLogSystem) Println(v ...interface{}) {
|
2014-06-26 17:45:57 +00:00
|
|
|
t.logger.Println(v...)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
func (t *stdLogSystem) Printf(format string, v ...interface{}) {
|
2014-06-26 17:45:57 +00:00
|
|
|
t.logger.Printf(format, v...)
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
func (t *stdLogSystem) SetLogLevel(i LogLevel) {
|
2014-10-14 12:35:54 +00:00
|
|
|
atomic.StoreUint32(&t.level, uint32(i))
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|
|
|
|
|
2014-10-14 17:35:10 +00:00
|
|
|
func (t *stdLogSystem) GetLogLevel() LogLevel {
|
2014-10-14 12:35:54 +00:00
|
|
|
return LogLevel(atomic.LoadUint32(&t.level))
|
2014-06-23 11:49:04 +00:00
|
|
|
}
|