|
|
|
@ -1,3 +1,15 @@ |
|
|
|
|
/* |
|
|
|
|
Package ethlog implements a multi-output leveled logger. |
|
|
|
|
|
|
|
|
|
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. |
|
|
|
|
|
|
|
|
|
Logging is asynchronous and does not block the caller. Message |
|
|
|
|
formatting is performed by the caller goroutine to avoid incorrect |
|
|
|
|
logging of mutable state. |
|
|
|
|
*/ |
|
|
|
|
package ethlog |
|
|
|
|
|
|
|
|
|
import ( |
|
|
|
@ -6,46 +18,26 @@ import ( |
|
|
|
|
"log" |
|
|
|
|
"os" |
|
|
|
|
"sync" |
|
|
|
|
"sync/atomic" |
|
|
|
|
) |
|
|
|
|
|
|
|
|
|
// LogSystem is implemented by log output devices.
|
|
|
|
|
// All methods can be called concurrently from multiple goroutines.
|
|
|
|
|
type LogSystem interface { |
|
|
|
|
GetLogLevel() LogLevel |
|
|
|
|
SetLogLevel(i LogLevel) |
|
|
|
|
Println(v ...interface{}) |
|
|
|
|
Printf(format string, v ...interface{}) |
|
|
|
|
LogPrint(LogLevel, string) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
type logMessage struct { |
|
|
|
|
LogLevel LogLevel |
|
|
|
|
format bool |
|
|
|
|
msg string |
|
|
|
|
type message struct { |
|
|
|
|
level LogLevel |
|
|
|
|
msg string |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func newPrintlnLogMessage(level LogLevel, tag string, v ...interface{}) *logMessage { |
|
|
|
|
return &logMessage{level, false, fmt.Sprintf("[%s] %s", tag, fmt.Sprint(v...))} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func newPrintfLogMessage(level LogLevel, tag string, format string, v ...interface{}) *logMessage { |
|
|
|
|
return &logMessage{level, true, fmt.Sprintf("[%s] %s", tag, fmt.Sprintf(format, v...))} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func (msg *logMessage) send(logger LogSystem) { |
|
|
|
|
if msg.format { |
|
|
|
|
logger.Printf(msg.msg) |
|
|
|
|
} else { |
|
|
|
|
logger.Println(msg.msg) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
var logMessages chan (*logMessage) |
|
|
|
|
var logSystems []LogSystem |
|
|
|
|
var quit chan chan error |
|
|
|
|
var drained chan bool |
|
|
|
|
var mutex = sync.Mutex{} |
|
|
|
|
|
|
|
|
|
type LogLevel uint8 |
|
|
|
|
|
|
|
|
|
const ( |
|
|
|
|
// Standard log levels
|
|
|
|
|
Silence LogLevel = iota |
|
|
|
|
ErrorLevel |
|
|
|
|
WarnLevel |
|
|
|
@ -54,167 +46,203 @@ const ( |
|
|
|
|
DebugDetailLevel |
|
|
|
|
) |
|
|
|
|
|
|
|
|
|
func dispatch(msg *logMessage) { |
|
|
|
|
for _, logSystem := range logSystems { |
|
|
|
|
if logSystem.GetLogLevel() >= msg.LogLevel { |
|
|
|
|
msg.send(logSystem) |
|
|
|
|
} |
|
|
|
|
var ( |
|
|
|
|
logMessageC = make(chan message) |
|
|
|
|
addSystemC = make(chan LogSystem) |
|
|
|
|
flushC = make(chan chan struct{}) |
|
|
|
|
resetC = make(chan chan struct{}) |
|
|
|
|
) |
|
|
|
|
|
|
|
|
|
func init() { |
|
|
|
|
go dispatchLoop() |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// each system can buffer this many messages before
|
|
|
|
|
// blocking incoming log messages.
|
|
|
|
|
const sysBufferSize = 500 |
|
|
|
|
|
|
|
|
|
func dispatchLoop() { |
|
|
|
|
var ( |
|
|
|
|
systems []LogSystem |
|
|
|
|
systemIn []chan message |
|
|
|
|
systemWG sync.WaitGroup |
|
|
|
|
) |
|
|
|
|
bootSystem := func(sys LogSystem) { |
|
|
|
|
in := make(chan message, sysBufferSize) |
|
|
|
|
systemIn = append(systemIn, in) |
|
|
|
|
systemWG.Add(1) |
|
|
|
|
go sysLoop(sys, in, &systemWG) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// log messages are dispatched to log writers
|
|
|
|
|
func start() { |
|
|
|
|
for { |
|
|
|
|
select { |
|
|
|
|
case status := <-quit: |
|
|
|
|
status <- nil |
|
|
|
|
return |
|
|
|
|
case msg := <-logMessages: |
|
|
|
|
dispatch(msg) |
|
|
|
|
default: |
|
|
|
|
drained <- true // this blocks until a message is sent to the queue
|
|
|
|
|
case msg := <-logMessageC: |
|
|
|
|
for _, c := range systemIn { |
|
|
|
|
c <- msg |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
case sys := <-addSystemC: |
|
|
|
|
systems = append(systems, sys) |
|
|
|
|
bootSystem(sys) |
|
|
|
|
|
|
|
|
|
case waiter := <-resetC: |
|
|
|
|
// reset means terminate all systems
|
|
|
|
|
for _, c := range systemIn { |
|
|
|
|
close(c) |
|
|
|
|
} |
|
|
|
|
systems = nil |
|
|
|
|
systemIn = nil |
|
|
|
|
systemWG.Wait() |
|
|
|
|
close(waiter) |
|
|
|
|
|
|
|
|
|
case waiter := <-flushC: |
|
|
|
|
// flush means reboot all systems
|
|
|
|
|
for _, c := range systemIn { |
|
|
|
|
close(c) |
|
|
|
|
} |
|
|
|
|
systemIn = nil |
|
|
|
|
systemWG.Wait() |
|
|
|
|
for _, sys := range systems { |
|
|
|
|
bootSystem(sys) |
|
|
|
|
} |
|
|
|
|
close(waiter) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func send(msg *logMessage) { |
|
|
|
|
logMessages <- msg |
|
|
|
|
select { |
|
|
|
|
case <-drained: |
|
|
|
|
default: |
|
|
|
|
func sysLoop(sys LogSystem, in <-chan message, wg *sync.WaitGroup) { |
|
|
|
|
for msg := range in { |
|
|
|
|
if sys.GetLogLevel() >= msg.level { |
|
|
|
|
sys.LogPrint(msg.level, msg.msg) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
wg.Done() |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Reset removes all active log systems.
|
|
|
|
|
// It blocks until all current messages have been delivered.
|
|
|
|
|
func Reset() { |
|
|
|
|
mutex.Lock() |
|
|
|
|
defer mutex.Unlock() |
|
|
|
|
if logSystems != nil { |
|
|
|
|
status := make(chan error) |
|
|
|
|
quit <- status |
|
|
|
|
select { |
|
|
|
|
case <-drained: |
|
|
|
|
default: |
|
|
|
|
} |
|
|
|
|
<-status |
|
|
|
|
} |
|
|
|
|
waiter := make(chan struct{}) |
|
|
|
|
resetC <- waiter |
|
|
|
|
<-waiter |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// waits until log messages are drained (dispatched to log writers)
|
|
|
|
|
// Flush waits until all current log messages have been dispatched to
|
|
|
|
|
// the active log systems.
|
|
|
|
|
func Flush() { |
|
|
|
|
if logSystems != nil { |
|
|
|
|
<-drained |
|
|
|
|
} |
|
|
|
|
waiter := make(chan struct{}) |
|
|
|
|
flushC <- waiter |
|
|
|
|
<-waiter |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// AddLogSystem starts printing messages to the given LogSystem.
|
|
|
|
|
func AddLogSystem(sys LogSystem) { |
|
|
|
|
addSystemC <- sys |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
|
type Logger struct { |
|
|
|
|
tag string |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func NewLogger(tag string) *Logger { |
|
|
|
|
return &Logger{tag} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func AddLogSystem(logSystem LogSystem) { |
|
|
|
|
var mutex = &sync.Mutex{} |
|
|
|
|
mutex.Lock() |
|
|
|
|
defer mutex.Unlock() |
|
|
|
|
if logSystems == nil { |
|
|
|
|
logMessages = make(chan *logMessage, 10) |
|
|
|
|
quit = make(chan chan error, 1) |
|
|
|
|
drained = make(chan bool, 1) |
|
|
|
|
go start() |
|
|
|
|
} |
|
|
|
|
logSystems = append(logSystems, logSystem) |
|
|
|
|
return &Logger{"[" + tag + "] "} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func (logger *Logger) sendln(level LogLevel, v ...interface{}) { |
|
|
|
|
if logMessages != nil { |
|
|
|
|
msg := newPrintlnLogMessage(level, logger.tag, v...) |
|
|
|
|
send(msg) |
|
|
|
|
} |
|
|
|
|
logMessageC <- message{level, logger.tag + fmt.Sprintln(v...)} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func (logger *Logger) sendf(level LogLevel, format string, v ...interface{}) { |
|
|
|
|
if logMessages != nil { |
|
|
|
|
msg := newPrintfLogMessage(level, logger.tag, format, v...) |
|
|
|
|
send(msg) |
|
|
|
|
} |
|
|
|
|
logMessageC <- message{level, logger.tag + fmt.Sprintf(format, v...)} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Errorln writes a message with ErrorLevel.
|
|
|
|
|
func (logger *Logger) Errorln(v ...interface{}) { |
|
|
|
|
logger.sendln(ErrorLevel, v...) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Warnln writes a message with WarnLevel.
|
|
|
|
|
func (logger *Logger) Warnln(v ...interface{}) { |
|
|
|
|
logger.sendln(WarnLevel, v...) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Infoln writes a message with InfoLevel.
|
|
|
|
|
func (logger *Logger) Infoln(v ...interface{}) { |
|
|
|
|
logger.sendln(InfoLevel, v...) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Debugln writes a message with DebugLevel.
|
|
|
|
|
func (logger *Logger) Debugln(v ...interface{}) { |
|
|
|
|
logger.sendln(DebugLevel, v...) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// DebugDetailln writes a message with DebugDetailLevel.
|
|
|
|
|
func (logger *Logger) DebugDetailln(v ...interface{}) { |
|
|
|
|
logger.sendln(DebugDetailLevel, v...) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Errorf writes a message with ErrorLevel.
|
|
|
|
|
func (logger *Logger) Errorf(format string, v ...interface{}) { |
|
|
|
|
logger.sendf(ErrorLevel, format, v...) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Warnf writes a message with WarnLevel.
|
|
|
|
|
func (logger *Logger) Warnf(format string, v ...interface{}) { |
|
|
|
|
logger.sendf(WarnLevel, format, v...) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Infof writes a message with InfoLevel.
|
|
|
|
|
func (logger *Logger) Infof(format string, v ...interface{}) { |
|
|
|
|
logger.sendf(InfoLevel, format, v...) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Debugf writes a message with DebugLevel.
|
|
|
|
|
func (logger *Logger) Debugf(format string, v ...interface{}) { |
|
|
|
|
logger.sendf(DebugLevel, format, v...) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// DebugDetailf writes a message with DebugDetailLevel.
|
|
|
|
|
func (logger *Logger) DebugDetailf(format string, v ...interface{}) { |
|
|
|
|
logger.sendf(DebugDetailLevel, format, v...) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Fatalln writes a message with ErrorLevel and exits the program.
|
|
|
|
|
func (logger *Logger) Fatalln(v ...interface{}) { |
|
|
|
|
logger.sendln(ErrorLevel, v...) |
|
|
|
|
Flush() |
|
|
|
|
os.Exit(0) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Fatalf writes a message with ErrorLevel and exits the program.
|
|
|
|
|
func (logger *Logger) Fatalf(format string, v ...interface{}) { |
|
|
|
|
logger.sendf(ErrorLevel, format, v...) |
|
|
|
|
Flush() |
|
|
|
|
os.Exit(0) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
type StdLogSystem struct { |
|
|
|
|
logger *log.Logger |
|
|
|
|
level LogLevel |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func (t *StdLogSystem) Println(v ...interface{}) { |
|
|
|
|
t.logger.Println(v...) |
|
|
|
|
// 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)} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func (t *StdLogSystem) Printf(format string, v ...interface{}) { |
|
|
|
|
t.logger.Printf(format, v...) |
|
|
|
|
type stdLogSystem struct { |
|
|
|
|
logger *log.Logger |
|
|
|
|
level uint32 |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func (t *StdLogSystem) SetLogLevel(i LogLevel) { |
|
|
|
|
t.level = i |
|
|
|
|
func (t *stdLogSystem) LogPrint(level LogLevel, msg string) { |
|
|
|
|
t.logger.Print(msg) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func (t *StdLogSystem) GetLogLevel() LogLevel { |
|
|
|
|
return t.level |
|
|
|
|
func (t *stdLogSystem) SetLogLevel(i LogLevel) { |
|
|
|
|
atomic.StoreUint32(&t.level, uint32(i)) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func NewStdLogSystem(writer io.Writer, flags int, level LogLevel) *StdLogSystem { |
|
|
|
|
logger := log.New(writer, "", flags) |
|
|
|
|
return &StdLogSystem{logger, level} |
|
|
|
|
func (t *stdLogSystem) GetLogLevel() LogLevel { |
|
|
|
|
return LogLevel(atomic.LoadUint32(&t.level)) |
|
|
|
|
} |
|
|
|
|