improved design, non-blocking serial access logging

Author: jeevatkm

console_receiver.go

@@ -0,0 +1,93 @@
+// Copyright (c) Jeevanandam M (https://github.com/jeevatkm)
+// go-aah/log source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package log
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+
+	"aahframework.org/config.v0"
+)
+
+var (
+	// ANSI color codes
+	resetColor   = []byte("\033[0m")
+	levelToColor = [][]byte{
+		levelFatal: []byte("\033[0;31m"), // red
+		levelPanic: []byte("\033[0;31m"), // red
+		LevelError: []byte("\033[0;31m"), // red
+		LevelWarn:  []byte("\033[0;33m"), // yellow
+		LevelInfo:  []byte("\033[0;37m"), // white
+		LevelDebug: []byte("\033[0;34m"), // blue
+		LevelTrace: []byte("\033[0;35m"), // magenta (purple)
+	}
+
+	_ Receiver = &ConsoleReceiver{}
+)
+
+// ConsoleReceiver writes the log entry into os.Stderr.
+// For non-windows it  writes with color.
+type ConsoleReceiver struct {
+	out          io.Writer
+	formatter    string
+	flags        *[]FlagPart
+	isCallerInfo bool
+	isColor      bool
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// ConsoleReceiver methods
+//___________________________________
+
+// Init method initializes the console logger.
+func (c *ConsoleReceiver) Init(cfg *config.Config) error {
+	c.out = os.Stderr
+	c.isColor = runtime.GOOS != "windows"
+
+	c.formatter = cfg.StringDefault("log.format", "text")
+	if !(c.formatter == textFmt || c.formatter == jsonFmt) {
+		return fmt.Errorf("log: unsupported format '%s'", c.formatter)
+	}
+
+	return nil
+}
+
+// SetPattern method initializes the logger format pattern.
+func (c *ConsoleReceiver) SetPattern(pattern string) error {
+	flags, err := parseFlag(pattern)
+	if err != nil {
+		return err
+	}
+	c.flags = flags
+	if c.formatter == textFmt {
+		c.isCallerInfo = isCallerInfo(c.flags)
+	}
+	return nil
+}
+
+// IsCallerInfo method returns true if log receiver is configured with caller info
+// otherwise false.
+func (c *ConsoleReceiver) IsCallerInfo() bool {
+	return c.isCallerInfo
+}
+
+// Log method writes the log entry into os.Stderr.
+func (c *ConsoleReceiver) Log(entry *Entry) {
+	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' {
+		msg = append(msg, '\n')
+	}
+	_, _ = c.out.Write(msg)
+
+	if c.isColor {
+		_, _ = c.out.Write(resetColor)
+	}
+}

console_receiver_test.go

@@ -0,0 +1,107 @@
+// Copyright (c) Jeevanandam M (https://github.com/jeevatkm)
+// go-aah/log source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package log
+
+import (
+	"testing"
+	"time"
+
+	"aahframework.org/config.v0"
+	"aahframework.org/test.v0/assert"
+)
+
+func TestConsoleLoggerTextJSON(t *testing.T) {
+	// Text 1
+	textConfigStr1 := `
+  log {
+    receiver = "console"
+    level = "debug"
+    pattern = "%utctime:2006-01-02 15:04:05.000 %level:-5 %longfile %line %custom:- %message"
+  }
+  `
+	testConsoleLogger(t, textConfigStr1)
+
+	// Text 2
+	textConfigStr2 := `
+  log {
+    receiver = "console"
+    level = "debug"
+    pattern = "%time:2006-01-02 15:04:05.000 %level:-5 %shortfile %line %custom:- %message"
+  }
+  `
+	testConsoleLogger(t, textConfigStr2)
+
+	// JSON
+	jsonConfigStr := `
+  log {
+    receiver = "console"
+    level = "debug"
+    format = "json"
+  }
+  `
+	testConsoleLogger(t, jsonConfigStr)
+}
+
+func TestConsoleLoggerUnsupportedFormat(t *testing.T) {
+	configStr := `
+  log {
+    # default config plus
+    pattern = "%utctime:2006-01-02 15:04:05.000 %level:-5 %longfile %line %custom:- %message"
+    format = "xml"
+  }
+  `
+	cfg, _ := config.ParseString(configStr)
+	logger, err := New(cfg)
+	assert.Nil(t, logger)
+	assert.Equal(t, "log: unsupported format 'xml'", err.Error())
+}
+
+func TestConsoleLoggerUnknownFormatFlag(t *testing.T) {
+	configStr := `
+  log {
+    # default config plus
+    pattern = "%time:2006-01-02 15:04:05.000 %level:-5 %myfile %line %custom:- %message"
+  }
+  `
+	cfg, _ := config.ParseString(configStr)
+	logger, err := New(cfg)
+	assert.Nil(t, logger)
+	assert.Equal(t, "unrecognized log format flag: myfile", err.Error())
+}
+
+func TestConsoleLoggerDefaults(t *testing.T) {
+	configStr := `
+  log {
+    # default config
+  }
+  `
+	cfg, _ := config.ParseString(configStr)
+	logger, err := New(cfg)
+	assert.NotNil(t, logger)
+	assert.Nil(t, err)
+}
+
+func testConsoleLogger(t *testing.T, cfgStr string) {
+	cfg, _ := config.ParseString(cfgStr)
+	logger, err := New(cfg)
+	assert.FailNowOnError(t, err, "unexpected error")
+
+	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.Debugf("I would like to see this message, debug is useful for %v", "dev")
+
+	logger.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.Warnf("Yes, yes it's an %v", "warning")
+
+	logger.Error("Yes, yes, yes - finally an error")
+	logger.Errorf("Yes, yes, yes - %v", "finally an error")
+
+	time.Sleep(1 * time.Millisecond)
+}

default.go

@@ -7,106 +7,123 @@ package log
 import (
 	"fmt"
 	"os"
-)
 
-var stdLogger Logger
+	"aahframework.org/config.v0"
+)
 
-// Fatal logs message as `FATAL` and calls os.Exit(1)
-func Fatal(v ...interface{}) {
-	_ = stdLogger.Output(levelFatal, 2, nil, v...)
-	os.Exit(1)
-}
+var std *Logger
 
-// Fatalf logs message as `FATAL` and calls os.Exit(1)
-func Fatalf(format string, v ...interface{}) {
-	_ = stdLogger.Output(levelFatal, 2, &format, v...)
-	os.Exit(1)
-}
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Logger methods
+//_______________________________________
 
-// Panic logs message as `PANIC` and calls panic()
-func Panic(v ...interface{}) {
-	_ = stdLogger.Output(levelPanic, 2, nil, v...)
-	panic("")
-}
-
-// Panicf logs message as `PANIC` and calls panic()
-func Panicf(format string, v ...interface{}) {
-	_ = stdLogger.Output(levelPanic, 2, &format, v...)
-	panic(fmt.Sprintf(format, v...))
-}
-
-// Error logs message as `LevelError`
+// Error logs message as `ERROR`. Arguments handled in the mananer of `fmt.Print`.
 func Error(v ...interface{}) {
-	_ = stdLogger.Output(LevelError, 2, nil, v...)
+	std.output(LevelError, 3, nil, v...)
 }
 
-// Errorf logs message as `LevelError`
+// Errorf logs message as `ERROR`. Arguments handled in the mananer of `fmt.Printf`.
 func Errorf(format string, v ...interface{}) {
-	_ = stdLogger.Output(LevelError, 2, &format, v...)
+	std.output(LevelError, 3, &format, v...)
 }
 
-// Warn logs message as `LevelWarn`
+// Warn logs message as `WARN`. Arguments handled in the mananer of `fmt.Print`.
 func Warn(v ...interface{}) {
-	_ = stdLogger.Output(LevelWarn, 2, nil, v...)
+	std.output(LevelWarn, 3, nil, v...)
 }
 
-// Warnf logs message as `LevelWarn`
+// Warnf logs message as `WARN`. Arguments handled in the mananer of `fmt.Printf`.
 func Warnf(format string, v ...interface{}) {
-	_ = stdLogger.Output(LevelWarn, 2, &format, v...)
+	std.output(LevelWarn, 3, &format, v...)
 }
 
-// Info logs message as `LevelInfo`
+// Info logs message as `INFO`. Arguments handled in the mananer of `fmt.Print`.
 func Info(v ...interface{}) {
-	_ = stdLogger.Output(LevelInfo, 2, nil, v...)
+	std.output(LevelInfo, 3, nil, v...)
 }
 
-// Infof logs message as `LevelInfo`
+// Infof logs message as `INFO`. Arguments handled in the mananer of `fmt.Printf`.
 func Infof(format string, v ...interface{}) {
-	_ = stdLogger.Output(LevelInfo, 2, &format, v...)
+	std.output(LevelInfo, 3, &format, v...)
 }
 
-// Debug logs message as `LevelDebug`
+// Debug logs message as `DEBUG`. Arguments handled in the mananer of `fmt.Print`.
 func Debug(v ...interface{}) {
-	_ = stdLogger.Output(LevelDebug, 2, nil, v...)
+	std.output(LevelDebug, 3, nil, v...)
 }
 
-// Debugf logs message as `LevelDebug`
+// Debugf logs message as `DEBUG`. Arguments handled in the mananer of `fmt.Printf`.
 func Debugf(format string, v ...interface{}) {
-	_ = stdLogger.Output(LevelDebug, 2, &format, v...)
+	std.output(LevelDebug, 3, &format, v...)
 }
 
-// Trace logs message as `LevelTrace`
+// Trace logs message as `TRACE`. Arguments handled in the mananer of `fmt.Print`.
 func Trace(v ...interface{}) {
-	_ = stdLogger.Output(LevelTrace, 2, nil, v...)
+	std.output(LevelTrace, 3, nil, v...)
 }
 
-// Tracef logs message as `LevelTrace`
+// Tracef logs message as `TRACE`. Arguments handled in the mananer of `fmt.Printf`.
 func Tracef(format string, v ...interface{}) {
-	_ = stdLogger.Output(LevelTrace, 2, &format, v...)
+	std.output(LevelTrace, 3, &format, v...)
 }
 
-// Stats returns current logger statistics like number of lines written,
-// number of bytes written, etc.
-func Stats() *ReceiverStats {
-	return stdLogger.Stats()
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Logger methods - Drop-in replacement
+// for Go standard logger
+//_______________________________________
+
+// Print logs message as `INFO`. Arguments handled in the mananer of `fmt.Print`.
+func Print(v ...interface{}) {
+	std.output(LevelInfo, 3, nil, v...)
 }
 
-// SetPattern sets the log entry format
-func SetPattern(pattern string) error {
-	return stdLogger.SetPattern(pattern)
+// 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...)
 }
 
-// SetLevel allows to set log level dynamically
-func SetLevel(level Level) {
-	stdLogger.SetLevel(level)
+// 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...)
 }
 
-// SetOutput allows to set standard logger implementation
-// which statisfies `Logger` interface
-func SetOutput(logger Logger) {
-	stdLogger = logger
+// Fatal logs message as `FATAL` and call to os.Exit(1).
+func Fatal(v ...interface{}) {
+	std.output(levelFatal, 3, nil, v...)
+	os.Exit(1)
+}
+
+// Fatalf logs message as `FATAL` and call to os.Exit(1).
+func Fatalf(format string, v ...interface{}) {
+	std.output(levelFatal, 3, &format, v...)
+	os.Exit(1)
+}
+
+// Fatalln logs message as `FATAL` and call to os.Exit(1).
+func Fatalln(format string, v ...interface{}) {
+	std.output(levelFatal, 3, &format, v...)
+	os.Exit(1)
+}
+
+// Panic logs message as `PANIC` and call to panic().
+func Panic(v ...interface{}) {
+	std.output(levelPanic, 3, nil, v...)
+	panic("")
+}
+
+// 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...))
+}
+
+// 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 init() {
-	stdLogger, _ = New(`receiver = "CONSOLE"; level = "DEBUG";`)
+	cfg, _ := config.ParseString("log { }")
+	std, _ = New(cfg)
 }