refactor logging. Details:

- packages use tagged logger sending log messages to shared (process-wide) logging engine
- log writers (interface ethlog.LogSystem) can be added to the logging engine by wrappers/guis/clients
- shared logging engine dispatching to multiple log systems
- log level can be set separately per log system
- async logging thread: logging IO does not block main thread
- log messages are synchronously stringified to avoid incorrectly logging of changed states
- README.md
- loggers_test

ethlog/README.md

+## Features
+
+- packages use tagged logger sending log messages to shared (process-wide) logging engine
+- log writers (interface ethlog.LogSystem) can be added to the logging engine by wrappers/guis/clients
+- shared logging engine dispatching to multiple log systems
+- log level can be set separately per log system
+- async logging thread: logging IO does not block main thread 
+- log messages are synchronously stringified to avoid incorrectly logging of changed states 
+
+## Usage
+
+In an ethereum component package:
+
+    import "github.com/ethereum/eth-go/ethlog"
+
+    // package-wide logger using tag
+    var logger = ethlog.NewLogger("TAG")
+
+    logger.Infoln("this is info") # > [TAG] This is info
+
+Ethereum wrappers should register log systems conforming to ethlog.LogSystem
+
+    import "github.com/ethereum/eth-go/ethlog"
+    
+    type CustomLogWriter struct {
+      logLevel ethlog.LogLevel
+    }
+
+    func (t *TestLogSystem) SetLogLevel(i LogLevel) {
+      t.level = i
+    }
+
+    func (t *TestLogSystem) GetLogLevel() LogLevel {
+      return t.level
+    }
+
+    func (c *CustomLogWriter) Printf(format string, v...interface{}) {
+      //....
+    }
+
+    func (c *CustomLogWriter) Println(v...interface{}) {
+      //....
+    }
+
+    ethlog.AddLogWriter(&CustomLogWriter{})
+
+ethlog also provides constructors for that wrap io.Writers into a standard logger with a settable level:
+
+    filename := "test.log"
+    file, _ := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
+    fileLogSystem := NewStdLogSystem(file, 0, WarnLevel)
+    AddLogSystem(fileLogSystem)
+    stdOutLogSystem := NewStdLogSystem(os.Stdout, 0, WarnLevel)
+    AddLogSystem(stdOutLogSystem)
+
+
+
+

ethlog/loggers.go

+package ethlog
+
+import (
+  "fmt"
+  "sync"
+  "log"
+  "io"
+  "os"
+)
+
+type LogSystem interface {
+  GetLogLevel() LogLevel
+  SetLogLevel(i LogLevel)
+  Println(v ...interface{})
+  Printf(format string, v ...interface{})
+}
+
+type logMessage struct {
+  LogLevel  LogLevel
+  format    bool
+  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 drained = true
+
+type LogLevel uint8
+
+const (
+  Silence LogLevel = iota
+  ErrorLevel
+  WarnLevel
+  InfoLevel
+  DebugLevel
+)
+
+// log messages are dispatched to log writers
+func start() {
+  for {
+    select {
+      case msg := <- logMessages:
+        for _, logSystem := range logSystems {
+          if logSystem.GetLogLevel() >= msg.LogLevel {
+            msg.send(logSystem)
+          }
+        }
+      default:
+        drained = true
+    }
+  }
+}
+
+// waits until log messages are drained (dispatched to log writers)
+func Flush() {
+  for !drained {}
+}
+
+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)
+    go start()
+  }
+  logSystems = append(logSystems, logSystem)
+}
+
+func (logger *Logger) sendln(level LogLevel, v...interface{}) {
+  if logMessages != nil {
+    msg := newPrintlnLogMessage(level, logger.tag, v...)
+    drained = false
+    logMessages <- msg
+  }
+}
+
+func (logger *Logger) sendf(level LogLevel, format string, v...interface{}) {
+  if logMessages != nil {
+    msg := newPrintfLogMessage(level, logger.tag, format, v...)
+    drained = false
+    logMessages <- msg
+  }
+}
+
+func (logger *Logger) Errorln(v...interface{}) {
+  logger.sendln(ErrorLevel, v...)
+}
+
+func (logger *Logger) Warnln(v...interface{}) {
+  logger.sendln(WarnLevel, v...)
+}
+
+func (logger *Logger) Infoln(v...interface{}) {
+  logger.sendln(InfoLevel, v...)
+}
+
+func (logger *Logger) Debugln(v...interface{}) {
+  logger.sendln(DebugLevel, v...)
+}
+
+func (logger *Logger) Errorf(format string, v...interface{}) {
+  logger.sendf(ErrorLevel, format, v...)
+}
+
+func (logger *Logger) Warnf(format string, v...interface{}) {
+  logger.sendf(WarnLevel, format, v...)
+}
+
+func (logger *Logger) Infof(format string, v...interface{}) {
+  logger.sendf(InfoLevel, format, v...)
+}
+
+func (logger *Logger) Debugf(format string, v...interface{}) {
+  logger.sendf(DebugLevel, format, v...)
+}
+
+func (logger *Logger) Fatalln (v...interface{}) {
+  logger.sendln(ErrorLevel, v...)
+  Flush()
+  os.Exit(0)
+}
+
+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...)
+}
+
+func (t *StdLogSystem) Printf(format string, v ...interface{}) {
+  t.logger.Printf(format, v...)
+}
+
+func (t *StdLogSystem) SetLogLevel(i LogLevel) {
+  t.level = i
+}
+
+func (t *StdLogSystem) GetLogLevel() LogLevel {
+  return t.level
+}
+
+func NewStdLogSystem(writer io.Writer, flags int, level LogLevel) *StdLogSystem {
+  logger := log.New(writer, "", flags)
+  return &StdLogSystem{logger, level}
+}
+

ethlog/loggers_test.go

+package ethlog
+
+import (
+  "testing"
+  "fmt"
+  "io/ioutil"
+  "os"
+)
+
+type TestLogSystem struct {
+  Output string
+  level  LogLevel
+}
+
+func (t *TestLogSystem) Println(v ...interface{}) {
+  t.Output += fmt.Sprintln(v...)
+}
+
+func (t *TestLogSystem) Printf(format string, v ...interface{}) {
+  t.Output += fmt.Sprintf(format, v...)
+}
+
+func (t *TestLogSystem) SetLogLevel(i LogLevel) {
+  t.level = i
+}
+
+func (t *TestLogSystem) GetLogLevel() LogLevel {
+  return t.level
+}
+
+func quote(s string) string {
+  return fmt.Sprintf("'%s'", s)
+}
+
+func TestLoggerPrintln(t *testing.T) {
+  logger := NewLogger("TEST")
+  testLogSystem := &TestLogSystem{level: WarnLevel}
+  AddLogSystem(testLogSystem)
+  logger.Errorln("error")
+  logger.Warnln("warn")
+  logger.Infoln("info")
+  logger.Debugln("debug")
+  Flush()
+  output := testLogSystem.Output
+  fmt.Println(quote(output))
+  if output != "[TEST] error\n[TEST] warn\n" {
+    t.Error("Expected logger output '[TEST] error\\n[TEST] warn\\n', got ", quote(testLogSystem.Output))
+  }
+}
+
+func TestLoggerPrintf(t *testing.T) {
+  logger := NewLogger("TEST")
+  testLogSystem := &TestLogSystem{level: WarnLevel}
+  AddLogSystem(testLogSystem)
+  logger.Errorf("error to %v\n", *testLogSystem)
+  logger.Warnf("warn")
+  logger.Infof("info")
+  logger.Debugf("debug")
+  Flush()
+  output := testLogSystem.Output
+  fmt.Println(quote(output))
+  if output != "[TEST] error to { 2}\n[TEST] warn" {
+    t.Error("Expected logger output '[TEST] error to { 2}\\n[TEST] warn', got ", quote(testLogSystem.Output))
+  }
+}
+
+func TestMultipleLogSystems(t *testing.T) {
+  logger := NewLogger("TEST")
+  testLogSystem0 := &TestLogSystem{level: ErrorLevel}
+  testLogSystem1 := &TestLogSystem{level: WarnLevel}
+  AddLogSystem(testLogSystem0)
+  AddLogSystem(testLogSystem1)
+  logger.Errorln("error")
+  logger.Warnln("warn")
+  Flush()
+  output0 := testLogSystem0.Output
+  output1 := testLogSystem1.Output
+  if output0 != "[TEST] error\n" {
+    t.Error("Expected logger 0 output '[TEST] error\\n', got ", quote(testLogSystem0.Output))
+  }
+  if output1 != "[TEST] error\n[TEST] warn\n" {
+    t.Error("Expected logger 1 output '[TEST] error\\n[TEST] warn\\n', got ", quote(testLogSystem1.Output))
+  }
+}
+
+func TestFileLogSystem(t *testing.T) {
+  logger := NewLogger("TEST")
+  filename := "test.log"
+  file, _ := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
+  testLogSystem := NewStdLogSystem(file, 0, WarnLevel)
+  AddLogSystem(testLogSystem)
+  logger.Errorf("error to %s\n", filename)
+  logger.Warnln("warn")
+  Flush()
+  contents, _ :=  ioutil.ReadFile(filename)
+  output := string(contents)
+  fmt.Println(quote(output))
+  if output != "[TEST] error to test.log\n[TEST] warn\n" {
+    t.Error("Expected contents of file 'test.log': '[TEST] error to test.log\\n[TEST] warn\\n', got ", quote(output))
+  } else {
+    os.Remove(filename)
+  }
+}
+
+func TestNoLogSystem(t *testing.T) {
+  logger := NewLogger("TEST")
+  logger.Warnln("warn")
+  Flush()
+}
+
+
+
+
+
+