context/field based logging support go-aah/aah#111

turn off color config for console recevier go-aah/aah#108

Author: jeevatkm

console_receiver.go

@@ -5,10 +5,12 @@
 package log
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
 	"os"
 	"runtime"
+	"sync"
 
 	"aahframework.org/config.v0"
 	"aahframework.org/essentials.v0"
@@ -38,6 +40,7 @@ type ConsoleReceiver struct {
 	flags        []ess.FmtFlagPart
 	isCallerInfo bool
 	isColor      bool
+	mu           *sync.Mutex
 }
 
 //‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
@@ -49,11 +52,17 @@ func (c *ConsoleReceiver) Init(cfg *config.Config) error {
 	c.out = os.Stderr
 	c.isColor = runtime.GOOS != "windows"
 
+	if v, found := cfg.Bool("log.color"); found {
+		c.isColor = v
+	}
+
 	c.formatter = cfg.StringDefault("log.format", "text")
 	if !(c.formatter == textFmt || c.formatter == jsonFmt) {
 		return fmt.Errorf("log: unsupported format '%s'", c.formatter)
 	}
 
+	c.mu = &sync.Mutex{}
+
 	return nil
 }
 
@@ -83,12 +92,18 @@ func (c *ConsoleReceiver) IsCallerInfo() bool {
 
 // Log method writes the log entry into os.Stderr.
 func (c *ConsoleReceiver) Log(entry *Entry) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
 	if c.isColor {
 		_, _ = c.out.Write(levelToColor[entry.Level])
 	}
 
-	msg := applyFormatter(c.formatter, c.flags, entry)
-	if len(msg) == 0 || msg[len(msg)-1] != '\n' {
+	var msg []byte
+	if c.formatter == textFmt {
+		msg = textFormatter(c.flags, entry)
+	} else {
+		msg, _ = json.Marshal(entry)
 		msg = append(msg, '\n')
 	}
 	_, _ = c.out.Write(msg)

console_receiver_test.go

@@ -20,6 +20,7 @@ func TestConsoleLoggerTextJSON(t *testing.T) {
     receiver = "console"
     level = "debug"
     pattern = "%utctime:2006-01-02 15:04:05.000 %level:-5 %longfile %line %custom:- %message"
+		color = true
   }
   `
 	testConsoleLogger(t, textConfigStr1)
@@ -29,7 +30,7 @@ func TestConsoleLoggerTextJSON(t *testing.T) {
   log {
     receiver = "console"
     level = "debug"
-    pattern = "%time:2006-01-02 15:04:05.000 %level:-5 %shortfile %line %custom:- %message"
+    pattern = "%time:2006-01-02 15:04:05.000 %appname %reqid %principal %level:-5 %shortfile %line %custom:- %message"
   }
   `
 	testConsoleLogger(t, textConfigStr2)
@@ -112,13 +113,13 @@ func testConsoleLogger(t *testing.T, cfgStr string) {
 	logger.Trace("I shoudn't see this msg, because standard logger level is DEBUG")
 	logger.Tracef("I shoudn't see this msg, because standard logger level is DEBUG: %v", 4)
 
-	logger.Debug("I would like to see this message, debug is useful for dev")
+	logger.WithField("appname", "testlogapp").Debug("I would like to see this message, debug is useful for dev")
 	logger.Debugf("I would like to see this message, debug is useful for %v", "dev")
 
-	logger.Info("Yes, I would love to see")
+	logger.WithField("reqid", "40139CA6368607085BF6").Info("Yes, I would love to see")
 	logger.Infof("Yes, I would love to %v", "see")
 
-	logger.Warn("Yes, yes it's an warning")
+	logger.WithField("principal", "jeevanandam").Warn("Yes, yes it's an warning")
 	logger.Warnf("Yes, yes it's an %v", "warning")
 
 	logger.Error("Yes, yes, yes - finally an error")
@@ -127,7 +128,7 @@ func testConsoleLogger(t *testing.T, cfgStr string) {
 	exit = func(code int) {}
 	logger.Fatal("Yes, yes, yes - at last fatal")
 	logger.Fatalf("Yes, yes, yes - %v", "at last fatal")
-	logger.Fatalln("Yes, yes, yes - %v", "at last fatal")
+	logger.Fatalln("Yes, yes, yes ", "at last fatal")
 	exit = os.Exit
 
 	assert.NotNil(t, logger.ToGoLogger())

default.go

@@ -5,67 +5,66 @@
 package log
 
 import (
-	"fmt"
 	"io"
 	slog "log"
 
 	"aahframework.org/config.v0"
 )
 
-var std *Logger
+var dl *Logger
 
 //‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
 // Logger methods
 //_______________________________________
 
 // Error logs message as `ERROR`. Arguments handled in the mananer of `fmt.Print`.
 func Error(v ...interface{}) {
-	std.output(LevelError, 3, nil, v...)
+	dl.Error(v...)
 }
 
 // Errorf logs message as `ERROR`. Arguments handled in the mananer of `fmt.Printf`.
 func Errorf(format string, v ...interface{}) {
-	std.output(LevelError, 3, &format, v...)
+	dl.Errorf(format, v...)
 }
 
 // Warn logs message as `WARN`. Arguments handled in the mananer of `fmt.Print`.
 func Warn(v ...interface{}) {
-	std.output(LevelWarn, 3, nil, v...)
+	dl.Warn(v...)
 }
 
 // Warnf logs message as `WARN`. Arguments handled in the mananer of `fmt.Printf`.
 func Warnf(format string, v ...interface{}) {
-	std.output(LevelWarn, 3, &format, v...)
+	dl.Warnf(format, v...)
 }
 
 // Info logs message as `INFO`. Arguments handled in the mananer of `fmt.Print`.
 func Info(v ...interface{}) {
-	std.output(LevelInfo, 3, nil, v...)
+	dl.Info(v...)
 }
 
 // Infof logs message as `INFO`. Arguments handled in the mananer of `fmt.Printf`.
 func Infof(format string, v ...interface{}) {
-	std.output(LevelInfo, 3, &format, v...)
+	dl.Infof(format, v...)
 }
 
 // Debug logs message as `DEBUG`. Arguments handled in the mananer of `fmt.Print`.
 func Debug(v ...interface{}) {
-	std.output(LevelDebug, 3, nil, v...)
+	dl.Debug(v...)
 }
 
 // Debugf logs message as `DEBUG`. Arguments handled in the mananer of `fmt.Printf`.
 func Debugf(format string, v ...interface{}) {
-	std.output(LevelDebug, 3, &format, v...)
+	dl.Debugf(format, v...)
 }
 
 // Trace logs message as `TRACE`. Arguments handled in the mananer of `fmt.Print`.
 func Trace(v ...interface{}) {
-	std.output(LevelTrace, 3, nil, v...)
+	dl.Trace(v...)
 }
 
 // Tracef logs message as `TRACE`. Arguments handled in the mananer of `fmt.Printf`.
 func Tracef(format string, v ...interface{}) {
-	std.output(LevelTrace, 3, &format, v...)
+	dl.Tracef(format, v...)
 }
 
 //‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
@@ -75,78 +74,82 @@ func Tracef(format string, v ...interface{}) {
 
 // Print logs message as `INFO`. Arguments handled in the mananer of `fmt.Print`.
 func Print(v ...interface{}) {
-	std.output(LevelInfo, 3, nil, v...)
+	dl.Print(v...)
 }
 
 // Printf logs message as `INFO`. Arguments handled in the mananer of `fmt.Printf`.
 func Printf(format string, v ...interface{}) {
-	std.output(LevelInfo, 3, &format, v...)
+	dl.Printf(format, v...)
 }
 
 // Println logs message as `INFO`. Arguments handled in the mananer of `fmt.Printf`.
-func Println(format string, v ...interface{}) {
-	std.output(LevelInfo, 3, &format, v...)
+func Println(v ...interface{}) {
+	dl.Println(v...)
 }
 
 // Fatal logs message as `FATAL` and call to os.Exit(1).
 func Fatal(v ...interface{}) {
-	std.output(levelFatal, 3, nil, v...)
-	exit(1)
+	dl.Fatal(v...)
 }
 
 // Fatalf logs message as `FATAL` and call to os.Exit(1).
 func Fatalf(format string, v ...interface{}) {
-	std.output(levelFatal, 3, &format, v...)
-	exit(1)
+	dl.Fatalf(format, v...)
 }
 
 // Fatalln logs message as `FATAL` and call to os.Exit(1).
 func Fatalln(v ...interface{}) {
-	std.output(levelFatal, 3, nil, v...)
-	exit(1)
+	dl.Fatalln(v...)
 }
 
 // Panic logs message as `PANIC` and call to panic().
 func Panic(v ...interface{}) {
-	std.output(levelPanic, 3, nil, v...)
-	panic("")
+	dl.Panic(v...)
 }
 
 // Panicf logs message as `PANIC` and call to panic().
 func Panicf(format string, v ...interface{}) {
-	std.output(levelPanic, 3, &format, v...)
-	panic(fmt.Sprintf(format, v...))
+	dl.Panicf(format, v...)
 }
 
 // Panicln logs message as `PANIC` and call to panic().
-func Panicln(format string, v ...interface{}) {
-	std.output(levelPanic, 3, &format, v...)
-	panic(fmt.Sprintf(format, v...))
+func Panicln(v ...interface{}) {
+	dl.Panicln(v...)
+}
+
+// WithFields method to add multiple key-value pairs into log.
+func WithFields(fields Fields) *Entry {
+	return dl.WithFields(fields)
+}
+
+// WithField method to add single key-value into log
+func WithField(key string, value interface{}) *Entry {
+	return dl.WithField(key, value)
 }
 
 // Writer method returns the writer of default logger.
 func Writer() io.Writer {
-	return std.receiver.Writer()
+	return dl.receiver.Writer()
 }
 
 // ToGoLogger method wraps the current log writer into Go Logger instance.
 func ToGoLogger() *slog.Logger {
-	return std.ToGoLogger()
+	return dl.ToGoLogger()
 }
 
 // SetDefaultLogger method sets the given logger instance as default logger.
 func SetDefaultLogger(l *Logger) {
-	std = l
+	dl = l
 }
 
 // SetLevel method sets log level for default logger.
 func SetLevel(level string) error {
-	return std.SetLevel(level)
+	return dl.SetLevel(level)
 }
 
 // SetPattern method sets the log format pattern for default logger.
 func SetPattern(pattern string) error {
-	return std.SetPattern(pattern)
+	return dl.SetPattern(pattern)
 }
 
 //‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
@@ -155,35 +158,35 @@ func SetPattern(pattern string) error {
 
 // Level method returns currently enabled logging level.
 func Level() string {
-	return std.Level()
+	return dl.Level()
 }
 
 // IsLevelInfo method returns true if log level is INFO otherwise false.
 func IsLevelInfo() bool {
-	return std.IsLevelInfo()
+	return dl.IsLevelInfo()
 }
 
 // IsLevelError method returns true if log level is ERROR otherwise false.
 func IsLevelError() bool {
-	return std.IsLevelError()
+	return dl.IsLevelError()
 }
 
 // IsLevelWarn method returns true if log level is WARN otherwise false.
 func IsLevelWarn() bool {
-	return std.IsLevelWarn()
+	return dl.IsLevelWarn()
 }
 
 // IsLevelDebug method returns true if log level is DEBUG otherwise false.
 func IsLevelDebug() bool {
-	return std.IsLevelDebug()
+	return dl.IsLevelDebug()
 }
 
 // IsLevelTrace method returns true if log level is TRACE otherwise false.
 func IsLevelTrace() bool {
-	return std.IsLevelTrace()
+	return dl.IsLevelTrace()
 }
 
 func init() {
 	cfg, _ := config.ParseString("log { }")
-	std, _ = New(cfg)
+	dl, _ = New(cfg)
 }