Merge pull request #1 from rjbasitali/logfmt

Logfmt

fields.go

@@ -0,0 +1,12 @@
+package log
+
+func (l myLogger) WithFields(fields Fields) Logger {
+	if l.data != nil && len(l.data) > 0 {
+		for k, v := range fields {
+			l.data[k] = v
+		}
+	} else {
+		l.data = fields
+	}
+	return l
+}

logger.go

@@ -29,4 +29,6 @@ type Logger interface {
 	End(a ...interface{})
 
 	Level(uint8) Logger
+
+	WithFields(fields Fields) Logger
 }

logger_alert.go

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

logger_begin.go

@@ -3,7 +3,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}
+	if hasLevel(l.level, logFlag) {
-	l.log(append([]interface{}{"BEGIN"}, s...)...)
+		l.log(logFlag, append([]interface{}{"BEGIN"}, s...)...)
+	}
+	logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: l.prefix, begin: time.Now(), level: l.level, data: l.data}
 	return logger
 }

logger_end.go

@@ -6,6 +6,8 @@ import (
 )
 
 func (l myLogger) End(s ...interface{}) {
-	var p []interface{} = append([]interface{}{fmt.Sprintf("END δt=%dµs", time.Now().Sub(l.begin)/1000)}, s...)
+	if hasLevel(l.level, logFlag) {
-	l.log(p...)
+		var p []interface{} = append([]interface{}{fmt.Sprintf("END δt=%dµs", time.Now().Sub(l.begin)/1000)}, s...)
+		l.log(logFlag, p...)
+	}
 }

logger_error.go

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

logger_highlight.go

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

logger_inform.go

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

logger_level.go

@@ -2,12 +2,12 @@ package log
 
 const (
 	alertFlag     = 0b00000001 // L1
-	errorFlag     = 0b00000001 // L1
+	errorFlag     = 0b00000010 // L2
-	warnFlag      = 0b00000010 // L2
+	warnFlag      = 0b00000100 // L3
-	highlightFlag = 0b00000100 // L3
+	highlightFlag = 0b00001000 // L4
-	informFlag    = 0b00001000 // L4
+	informFlag    = 0b00010000 // L5
-	logFlag       = 0b00010000 // L5
+	logFlag       = 0b00100000 // L6
-	traceFlag     = 0b00100000 // L6
+	traceFlag     = 0b01000000 // L7
 )
 
 // Level returns a leveled logger, level can be from 1 to 6.
@@ -20,26 +20,49 @@ const (
 // Anything above 6 as level will be considered Level 6.
 // Pass 0 to output no logs.
 func (l myLogger) Level(level uint8) Logger {
-	logger := myLogger{Writer: l.Writer, prefix: l.prefix, begin: l.begin}
+	logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: l.prefix, begin: l.begin, data: l.data}
 	switch level {
-	case 0:
-		logger.level = 0
 	case 1:
-		logger.level = alertFlag | errorFlag
+		logger.level = alertFlag
 	case 2:
-		logger.level = alertFlag | errorFlag | warnFlag
+		logger.level = alertFlag | errorFlag
 	case 3:
-		logger.level = alertFlag | errorFlag | warnFlag | highlightFlag
+		logger.level = alertFlag | errorFlag | warnFlag
 	case 4:
-		logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag
+		logger.level = alertFlag | errorFlag | warnFlag | highlightFlag
 	case 5:
+		logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag
+	case 6:
 		logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag | logFlag
-	default:
+	case 7:
 		logger.level = alertFlag | errorFlag | warnFlag | highlightFlag | informFlag | logFlag | traceFlag
+	default:
+		logger.level = 0
 	}
 	return logger
 }
 
+func unmarshalLevel(level uint8) string {
+	switch level {
+	case alertFlag:
+		return "alert"
+	case errorFlag:
+		return "error"
+	case warnFlag:
+		return "warn"
+	case highlightFlag:
+		return "highlight"
+	case informFlag:
+		return "inform"
+	case logFlag:
+		return "log"
+	case traceFlag:
+		return "trace"
+	default:
+		return ""
+	}
+}
+
 func hasLevel(b uint8, flag uint8) bool {
 	return b&flag != 0
 }

logger_log.go

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

logger_prefix.go

@@ -11,6 +11,6 @@ func (l myLogger) Prefix(p ...string) Logger {
 	for _, prefix := range p {
 		buffer.WriteString(fmt.Sprintf("%s: ", prefix))
 	}
-	logger := myLogger{Writer: l.Writer, prefix: buffer.String()}
+	logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: buffer.String(), data: l.data}
 	return logger
 }

logger_trace.go

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

logger_warn.go

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

my_logger.go

@@ -9,27 +9,66 @@ import (
 	"time"
 )
 
+var (
+	DefaultTimeFormat = time.RFC3339
+)
+
+type Fields map[string]interface{}
+
 type myLogger struct {
-	Writer io.Writer
+	Writer    io.Writer
-	prefix string
+	ErrWriter io.Writer
-	begin  time.Time
+	prefix    string
-	level  uint8
+	begin     time.Time
+	level     uint8
+	data      Fields
 }
 
-func (l myLogger) log(s ...interface{}) {
+func logPrefix(level uint8) string {
-	if l.Writer == nil {
+	return fmt.Sprintf("time=%q level=%s function=%s", time.Now().Format(DefaultTimeFormat), unmarshalLevel(level), funcName())
-		return
-	}
-	s = append([]interface{}{l.prefix, funcName()}, s...)
-	fmt.Fprintln(l.Writer, s...)
 }
 
-func (l myLogger) logf(format string, s ...interface{}) {
+func (fields Fields) String() string {
-	if l.Writer == nil {
+	if len(fields) == 0 {
-		return
+		return ""
 	}
-	format = fmt.Sprintf("%s %s %s\n", l.prefix, funcName(), format)
+	var buffer strings.Builder
-	fmt.Fprintf(l.Writer, format, s...)
+	for k, v := range fields {
+		switch v := v.(type) {
+		case string:
+			buffer.WriteString(fmt.Sprintf(" %s=%q", k, v))
+		default:
+			buffer.WriteString(fmt.Sprintf(" %s=%v", k, v))
+		}
+	}
+	return buffer.String()
+}
+
+func (l myLogger) log(flag uint8, s ...interface{}) {
+	var w io.Writer
+	{
+		if flag == errorFlag {
+			w = l.ErrWriter
+		} else {
+			w = l.Writer
+		}
+	}
+	f := fmt.Sprintf("%s%s msg=%q%s", logPrefix(flag), l.prefix, fmt.Sprint(s...), l.data)
+	fmt.Fprintln(w, f)
+}
+
+func (l myLogger) logf(flag uint8, format string, s ...interface{}) {
+	var w io.Writer
+	{
+		if flag == errorFlag {
+			w = l.ErrWriter
+		} else {
+			w = l.Writer
+		}
+	}
+	format = fmt.Sprintf("%%s%%s msg=\"%s\"%s\n", format, l.data)
+	s = append([]interface{}{logPrefix(flag), l.prefix}, s...)
+	fmt.Fprintf(w, format, s...)
 }
 
 func funcName() string {
@@ -38,19 +77,28 @@ func funcName() string {
 	for _, p := range pc {
 		fn := runtime.FuncForPC(p)
 		if !strings.HasPrefix(fn.Name(), "github.com/rjbasitali/go-log") {
-			return fn.Name()
+			fname := fn.Name()
+			i := strings.LastIndexByte(fname, byte('/'))
+			if i == -1 {
+				return fname
+			}
+			return fname[i+1:]
 		}
 	}
 	return ""
 }
 
-func NewLogger(w io.Writer) Logger {
+func NewLogger(w, errw io.Writer) Logger {
 	if w == nil {
 		w = os.Stdout
 	}
+	if errw == nil {
+		errw = os.Stderr
+	}
 	return myLogger{
-		Writer: w,
+		Writer:    w,
-		begin:  time.Now(),
+		ErrWriter: errw,
-		level:  63,
+		begin:     time.Now(),
+		level:     traceFlag,
 	}
 }