Initial commit

backend.go

@@ -0,0 +1,43 @@
+package logging
+
+import (
+	"io"
+	"os"
+)
+
+type Backend interface {
+	Write(*Record) error
+	SetLevel(Level)
+	SetFormatter(*Formatter)
+}
+
+type StdoutBackend struct {
+	l         io.Writer
+	level     Level
+	formatter *Formatter
+}
+
+func NewStdoutBackend() (b *StdoutBackend) {
+	b = &StdoutBackend{
+		l:         os.Stdout,
+		formatter: &defaultFormatter,
+	}
+	return
+}
+
+func (b StdoutBackend) Write(r *Record) error {
+	if r.Level >= b.level {
+		//check back for auto dereferencing
+		text := (*b.formatter)(r)
+		b.l.Write([]byte(text))
+	}
+	return nil
+}
+
+func (b *StdoutBackend) SetLevel(l Level) {
+	b.level = l
+}
+
+func (b *StdoutBackend) SetFormatter(f *Formatter) {
+	b.formatter = f
+}

logger.go

@@ -0,0 +1,86 @@
+package logging
+
+import (
+	"fmt"
+	"os"
+)
+
+type Logger struct {
+	level    Level
+	backends []Backend
+}
+
+func NewLogger() (l *Logger) {
+	l = &Logger{
+		level: DEFAULT_LEVEL,
+	}
+	return
+}
+
+func (l *Logger) AddBackend(b Backend) {
+	l.backends = append(l.backends, b)
+}
+
+func (l *Logger) SetLevel(level Level) {
+	l.level = level
+	for _, backend := range l.backends {
+		backend.SetLevel(level)
+	}
+}
+
+func (l *Logger) Log(level Level, m string) {
+	r := NewRecord(level, m)
+	for _, backend := range l.backends {
+		//Should be dereferenced automatically ?
+		backend.Write(r)
+	}
+}
+
+func (l *Logger) Debug(text string) {
+	l.Log(DEBUG, text)
+}
+
+func (l *Logger) Debugf(text string, args ...interface{}) {
+	l.Debug(fmt.Sprintf(text, args...))
+}
+
+func (l *Logger) Info(text string) {
+	l.Log(INFO, text)
+}
+
+func (l *Logger) Infof(text string, args ...interface{}) {
+	l.Info(fmt.Sprintf(text, args...))
+}
+
+func (l *Logger) Warning(text string) {
+	l.Log(WARNING, text)
+}
+
+func (l *Logger) Warningf(text string, args ...interface{}) {
+	l.Warning(fmt.Sprintf(text, args...))
+}
+
+func (l *Logger) Error(text string) {
+	l.Log(ERROR, text)
+}
+
+func (l *Logger) Errorf(text string, args ...interface{}) {
+	l.Error(fmt.Sprintf(text, args...))
+}
+
+func (l *Logger) Critical(text string) {
+	l.Log(CRITICAL, text)
+}
+
+func (l *Logger) Criticalf(text string, args ...interface{}) {
+	l.Critical(fmt.Sprintf(text, args...))
+}
+
+func (l *Logger) Fatal(text string) {
+	l.Log(DEBUG, text)
+	os.Exit(100)
+}
+
+func (l *Logger) Fatalf(text string, args ...interface{}) {
+	l.Fatal(fmt.Sprintf(text, args...))
+}

logging.go

@@ -0,0 +1,45 @@
+package logging
+
+import (
+	"fmt"
+	"strings"
+)
+
+var logger *Logger
+
+type Level byte
+
+const (
+	DEBUG Level = iota
+	INFO
+	WARNING
+	ERROR
+	CRITICAL
+	FATAL
+	DEFAULT_LEVEL = INFO
+)
+
+var levelNames = [6]string{"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "FATAL"}
+
+func (l Level) Name() string {
+	return levelNames[l]
+}
+
+type Formatter func(*Record) string
+
+func GetLogger() (l *Logger) {
+	return logger
+}
+
+var defaultFormatter Formatter = func(r *Record) string {
+	return fmt.Sprintf("%s [%s] %s\n",
+		r.Timestamp.Format("2006/01/02 15:04:05"), r.Level.Name(),
+		strings.TrimSpace(r.Message))
+}
+
+func init() {
+	logger = NewLogger()
+	backend := NewStdoutBackend()
+	logger.AddBackend(backend)
+	logger.SetLevel(DEBUG)
+}

record.go

@@ -0,0 +1,20 @@
+package logging
+
+import (
+	"time"
+)
+
+type Record struct {
+	Timestamp time.Time
+	Level     Level
+	Message   string
+}
+
+func NewRecord(l Level, m string) (r *Record) {
+	r = &Record{
+		Level:     l,
+		Message:   m,
+		Timestamp: time.Now(),
+	}
+	return
+}