leveled logger

logger.go

@@ -1,39 +1,32 @@
 package log
 
-import (
+type Logger interface {
-	"fmt"
+	Alert(a ...interface{})
-	"io"
+	Alertf(format string, a ...interface{})
-)
 
-type Logger struct {
+	Error(a ...interface{})
-	Writer io.Writer
+	Errorf(format string, a ...interface{})
-}
 
-func (l Logger) Log(s ...interface{}) {
+	Highlight(a ...interface{})
-	if l.Writer == nil {
+	Highlightf(format string, a ...interface{})
-		return
-	}
-	fmt.Fprintln(l.Writer, s...)
-}
 
-func (l Logger) Logf(format string, s ...interface{}) {
+	Inform(a ...interface{})
-	if l.Writer == nil {
+	Informf(format string, a ...interface{})
-		return
-	}
-	format = fmt.Sprintf("%s%s", format, "\n")
-	fmt.Fprintf(l.Writer, format, s...)
-}
 
-func (l Logger) Begin(s ...interface{}) {
+	Log(a ...interface{})
-	var p []interface{} = append([]interface{}{"BEGIN "}, s...)
+	Logf(format string, a ...interface{})
-	l.Log(p...)
-}
 
-func (l Logger) End(s ...interface{}) {
+	Trace(a ...interface{})
-	var p []interface{} = append([]interface{}{"END "}, s...)
+	Tracef(format string, a ...interface{})
-	l.Log(p...)
-}
 
-func (l Logger) Error(s string, err error) {
+	Warn(a ...interface{})
-	l.Log(s, err)
+	Warnf(format string, a ...interface{})
+
+	Prefix(...string) Logger
+
+	Begin(a ...interface{}) Logger
+
+	End(a ...interface{})
+
+	Level(uint8) Logger
 }

logger_alert.go

@@ -0,0 +1,21 @@
+package log
+
+func (l myLogger) Alert(a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, alertFlag) {
+		return
+	}
+	l.log(a...)
+}
+
+func (l myLogger) Alertf(format string, a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, alertFlag) {
+		return
+	}
+	l.logf(format, a...)
+}

logger_begin.go

@@ -0,0 +1,9 @@
+package log
+
+import "time"
+
+func (l myLogger) Begin(s ...interface{}) Logger {
+	logger := myLogger{Writer: l.Writer, prefix: l.prefix, begin: time.Now(), level: l.level}
+	l.log(append([]interface{}{"BEGIN"}, s...)...)
+	return logger
+}

logger_end.go

@@ -0,0 +1,11 @@
+package log
+
+import (
+	"fmt"
+	"time"
+)
+
+func (l myLogger) End(s ...interface{}) {
+	var p []interface{} = append([]interface{}{fmt.Sprintf("END δt=%dµs", time.Now().Sub(l.begin)/1000)}, s...)
+	l.log(p...)
+}

logger_error.go

@@ -0,0 +1,21 @@
+package log
+
+func (l myLogger) Error(a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, errorFlag) {
+		return
+	}
+	l.log(a...)
+}
+
+func (l myLogger) Errorf(format string, a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, errorFlag) {
+		return
+	}
+	l.logf(format, a...)
+}

logger_highlight.go

@@ -0,0 +1,21 @@
+package log
+
+func (l myLogger) Highlight(a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, highlightFlag) {
+		return
+	}
+	l.log(a...)
+}
+
+func (l myLogger) Highlightf(format string, a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, highlightFlag) {
+		return
+	}
+	l.logf(format, a...)
+}

logger_inform.go

@@ -0,0 +1,21 @@
+package log
+
+func (l myLogger) Inform(a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, informFlag) {
+		return
+	}
+	l.log(a...)
+}
+
+func (l myLogger) Informf(format string, a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, informFlag) {
+		return
+	}
+	l.logf(format, a...)
+}

logger_level.go

@@ -0,0 +1,34 @@
+package log
+
+const (
+	alertFlag     = 0b00000001 // L1
+	errorFlag     = 0b00000001 // L1
+	warnFlag      = 0b00000010 // L2
+	highlightFlag = 0b00000100 // L3
+	informFlag    = 0b00001000 // L4
+	logFlag       = 0b00010000 // L5
+	traceFlag     = 0b00100000 // L6
+)
+
+func (l myLogger) Level(level uint8) Logger {
+	logger := myLogger{Writer: l.Writer, prefix: l.prefix, begin: l.begin}
+	switch level {
+	case 1:
+		logger.level = alertFlag | errorFlag
+	case 2:
+		logger.level = alertFlag | errorFlag | warnFlag
+	case 3:
+		logger.level = alertFlag | errorFlag | warnFlag | highlightFlag
+	case 4:
+		logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag
+	case 5:
+		logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag | logFlag
+	default:
+		logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag | logFlag | traceFlag
+	}
+	return logger
+}
+
+func hasLevel(b uint8, flag uint8) bool {
+	return b&flag != 0
+}

logger_log.go

@@ -0,0 +1,21 @@
+package log
+
+func (l myLogger) Log(s ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, logFlag) {
+		return
+	}
+	l.log(s...)
+}
+
+func (l myLogger) Logf(format string, s ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, logFlag) {
+		return
+	}
+	l.logf(format, s...)
+}

logger_prefix.go

@@ -0,0 +1,16 @@
+package log
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (l myLogger) Prefix(p ...string) Logger {
+	var buffer strings.Builder
+	buffer.WriteString(l.prefix)
+	for _, prefix := range p {
+		buffer.WriteString(fmt.Sprintf("%s: ", prefix))
+	}
+	logger := myLogger{Writer: l.Writer, prefix: buffer.String()}
+	return logger
+}

logger_trace.go

@@ -0,0 +1,21 @@
+package log
+
+func (l myLogger) Trace(a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, traceFlag) {
+		return
+	}
+	l.log(a...)
+}
+
+func (l myLogger) Tracef(format string, a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, traceFlag) {
+		return
+	}
+	l.logf(format, a...)
+}

logger_warn.go

@@ -0,0 +1,21 @@
+package log
+
+func (l myLogger) Warn(a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, warnFlag) {
+		return
+	}
+	l.log(a...)
+}
+
+func (l myLogger) Warnf(format string, a ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	if !hasLevel(l.level, warnFlag) {
+		return
+	}
+	l.logf(format, a...)
+}

my_logger.go

@@ -0,0 +1,53 @@
+package log
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"strings"
+	"time"
+)
+
+type myLogger struct {
+	Writer io.Writer
+	prefix string
+	begin  time.Time
+	level  uint8
+}
+
+func (l myLogger) log(s ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	s = append([]interface{}{l.prefix, funcName()}, s...)
+	fmt.Fprintln(l.Writer, s...)
+}
+
+func (l myLogger) logf(format string, s ...interface{}) {
+	if l.Writer == nil {
+		return
+	}
+	format = fmt.Sprintf("%s %s %s\n", l.prefix, funcName(), format)
+	fmt.Fprintf(l.Writer, format, s...)
+}
+
+func funcName() string {
+	pc := make([]uintptr, 10)
+	runtime.Callers(2, pc)
+	for _, p := range pc {
+		fn := runtime.FuncForPC(p)
+		if !strings.HasPrefix(fn.Name(), "github.com/rjbasitali/go-log") {
+			return fn.Name()
+		}
+	}
+	return ""
+}
+
+func NewLogger() Logger {
+	return myLogger{
+		Writer: os.Stdout,
+		begin:  time.Now(),
+		level:  63,
+	}
+}