Refactor

log/event.go

@@ -0,0 +1,39 @@
+package log
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/xjasonlyu/tun2socks/common/observable"
+)
+
+var (
+	logCh  = make(chan interface{})
+	source = observable.NewObservable(logCh)
+)
+
+type Event struct {
+	Level   Level     `json:"level"`
+	Message string    `json:"msg"`
+	Time    time.Time `json:"time"`
+}
+
+func newEvent(level Level, format string, args ...interface{}) *Event {
+	event := &Event{
+		Level:   level,
+		Time:    time.Now(),
+		Message: fmt.Sprintf(format, args...),
+	}
+	logCh <- event /* send all events to logCh */
+
+	return event
+}
+
+func Subscribe() observable.Subscription {
+	sub, _ := source.Subscribe()
+	return sub
+}
+
+func UnSubscribe(sub observable.Subscription) {
+	source.UnSubscribe(sub)
+}

log/level.go

@@ -0,0 +1,72 @@
+package log
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+type Level uint32
+
+const (
+	SilentLevel Level = iota
+	ErrorLevel
+	WarnLevel
+	InfoLevel
+	DebugLevel
+)
+
+// UnmarshalJSON deserialize Level with json
+func (level *Level) UnmarshalJSON(data []byte) error {
+	var lvl string
+	if err := json.Unmarshal(data, &lvl); err != nil {
+		return err
+	}
+
+	l, err := ParseLevel(lvl)
+	if err != nil {
+		return err
+	}
+
+	*level = l
+	return nil
+}
+
+// MarshalJSON serialize Level with json
+func (level Level) MarshalJSON() ([]byte, error) {
+	return json.Marshal(level.String())
+}
+
+func (level Level) String() string {
+	switch level {
+	case DebugLevel:
+		return "debug"
+	case InfoLevel:
+		return "info"
+	case WarnLevel:
+		return "warning"
+	case ErrorLevel:
+		return "error"
+	case SilentLevel:
+		return "silent"
+	default:
+		return fmt.Sprintf("not a valid level %d", level)
+	}
+}
+
+func ParseLevel(lvl string) (Level, error) {
+	switch strings.ToLower(lvl) {
+	case "silent", "none":
+		return SilentLevel, nil
+	case "error":
+		return ErrorLevel, nil
+	case "warn", "warning":
+		return WarnLevel, nil
+	case "info":
+		return InfoLevel, nil
+	case "debug":
+		return DebugLevel, nil
+	default:
+		return Level(0), fmt.Errorf("not a valid logrus Level: %q", lvl)
+	}
+}

log/log.go

@@ -0,0 +1,60 @@
+package log
+
+import (
+	"os"
+	"sync/atomic"
+
+	"github.com/sirupsen/logrus"
+)
+
+var (
+	// defaultLevel is package default logging level.
+	defaultLevel = InfoLevel
+)
+
+func init() {
+	logrus.SetOutput(os.Stdout)
+	logrus.SetLevel(logrus.DebugLevel)
+}
+
+func SetLevel(level Level) {
+	atomic.StoreUint32((*uint32)(&defaultLevel), uint32(level))
+}
+
+func Debugf(format string, args ...interface{}) {
+	logf(DebugLevel, format, args...)
+}
+
+func Infof(format string, args ...interface{}) {
+	logf(InfoLevel, format, args...)
+}
+
+func Warnf(format string, args ...interface{}) {
+	logf(WarnLevel, format, args...)
+}
+
+func Errorf(format string, args ...interface{}) {
+	logf(ErrorLevel, format, args...)
+}
+
+func Fatalf(format string, args ...interface{}) {
+	logrus.Fatalf(format, args...)
+}
+
+func logf(level Level, format string, args ...interface{}) {
+	event := newEvent(level, format, args...)
+	if event.Level > defaultLevel {
+		return
+	}
+
+	switch level {
+	case DebugLevel:
+		logrus.WithTime(event.Time).Debugln(event.Message)
+	case InfoLevel:
+		logrus.WithTime(event.Time).Infoln(event.Message)
+	case WarnLevel:
+		logrus.WithTime(event.Time).Warnln(event.Message)
+	case ErrorLevel:
+		logrus.WithTime(event.Time).Errorln(event.Message)
+	}
+}