use ess as log pattern parser

Author: jeevatkm

console_receiver.go

@@ -11,6 +11,7 @@ import (
 	"runtime"
 
 	"aahframework.org/config.v0"
+	"aahframework.org/essentials.v0-unstable"
 )
 
 var (
@@ -34,7 +35,7 @@ var (
 type ConsoleReceiver struct {
 	out          io.Writer
 	formatter    string
-	flags        *[]FlagPart
+	flags        []ess.FmtFlagPart
 	isCallerInfo bool
 	isColor      bool
 }
@@ -58,7 +59,7 @@ func (c *ConsoleReceiver) Init(cfg *config.Config) error {
 
 // SetPattern method initializes the logger format pattern.
 func (c *ConsoleReceiver) SetPattern(pattern string) error {
-	flags, err := parseFlag(pattern)
+	flags, err := ess.ParseFmtFlag(pattern, FmtFlags)
 	if err != nil {
 		return err
 	}

console_receiver_test.go

@@ -68,7 +68,7 @@ func TestConsoleLoggerUnknownFormatFlag(t *testing.T) {
 	cfg, _ := config.ParseString(configStr)
 	logger, err := New(cfg)
 	assert.Nil(t, logger)
-	assert.Equal(t, "unrecognized log format flag: myfile", err.Error())
+	assert.Equal(t, "fmtflag: unknown flag 'myfile'", err.Error())
 }
 
 func TestConsoleLoggerUnknownLevel(t *testing.T) {

entry.go

@@ -57,24 +57,24 @@ func (e *Entry) Reset() {
 // Unexported methods
 //___________________________________
 
-// getEntry gets entry object from pool.
-func getEntry() *Entry {
+func acquireEntry() *Entry {
 	return entryPool.Get().(*Entry)
 }
 
-// putEntry reset the entry and puts it into Pool.
-func putEntry(e *Entry) {
-	e.Reset()
-	entryPool.Put(e)
+func releaseEntry(e *Entry) {
+	if e != nil {
+		e.Reset()
+		entryPool.Put(e)
+	}
 }
 
-// getBuffer gets buffer object from pool.
-func getBuffer() *bytes.Buffer {
+func acquireBuffer() *bytes.Buffer {
 	return bufPool.Get().(*bytes.Buffer)
 }
 
-// putBuffer reset the buffer and puts it into Pool.
-func putBuffer(buf *bytes.Buffer) {
-	buf.Reset()
-	bufPool.Put(buf)
+func releaseBuffer(buf *bytes.Buffer) {
+	if buf != nil {
+		buf.Reset()
+		bufPool.Put(buf)
+	}
 }

file_receiver.go

@@ -13,7 +13,7 @@ import (
 	"time"
 
 	"aahframework.org/config.v0"
-	"aahframework.org/essentials.v0"
+	"aahframework.org/essentials.v0-unstable"
 )
 
 var (
@@ -28,7 +28,7 @@ type FileReceiver struct {
 	filename     string
 	out          io.Writer
 	formatter    string
-	flags        *[]FlagPart
+	flags        []ess.FmtFlagPart
 	isCallerInfo bool
 	stats        *receiverStats
 	mu           *sync.Mutex
@@ -78,7 +78,7 @@ func (f *FileReceiver) Init(cfg *config.Config) error {
 
 // SetPattern method initializes the logger format pattern.
 func (f *FileReceiver) SetPattern(pattern string) error {
-	flags, err := parseFlag(pattern)
+	flags, err := ess.ParseFmtFlag(pattern, FmtFlags)
 	if err != nil {
 		return err
 	}

file_receiver_test.go

@@ -113,7 +113,7 @@ func TestFileLoggerUnknownFormatFlag(t *testing.T) {
 	cfg, _ := config.ParseString(configStr)
 	logger, err := New(cfg)
 	assert.Nil(t, logger)
-	assert.Equal(t, "unrecognized log format flag: myfile", err.Error())
+	assert.Equal(t, "fmtflag: unknown flag 'myfile'", err.Error())
 }
 
 func TestFileLoggerIncorrectSizeValue(t *testing.T) {

formatter.go

@@ -8,12 +8,13 @@ import (
 	"encoding/json"
 	"fmt"
 	"path/filepath"
-	"strings"
+
+	"aahframework.org/essentials.v0-unstable"
 )
 
 // Format flags used to define log message format for each log entry
 const (
-	FmtFlagLevel fmtFlag = iota
+	FmtFlagLevel ess.FmtFlag = iota
 	FmtFlagTime
 	FmtFlagUTCTime
 	FmtFlagLongfile
@@ -38,13 +39,10 @@ type (
 	//      Format: "2006-01-02 15:04:05.000",
 	//    }
 	FlagPart struct {
-		Flag   fmtFlag
+		Flag   ess.FmtFlag
 		Name   string
 		Format string
 	}
-
-	// FmtFlag type definition
-	fmtFlag uint8
 )
 
 var (
@@ -64,7 +62,7 @@ var (
 	//    line      - outputs file line number: L23
 	//    message   - outputs given message along supplied arguments if they present
 	//    custom    - outputs string as-is into log entry
-	FmtFlags = map[string]fmtFlag{
+	FmtFlags = map[string]ess.FmtFlag{
 		"level":     FmtFlagLevel,
 		"time":      FmtFlagTime,
 		"utctime":   FmtFlagUTCTime,
@@ -83,11 +81,11 @@ var (
 // textFormatter formats the `Entry` object details as per log `pattern`
 // 	For e.g.:
 // 		2016-07-02 22:26:01.530 INFO formatter_test.go L29 - Yes, I would love to see
-func textFormatter(flags *[]FlagPart, entry *Entry) []byte {
-	buf := getBuffer()
-	defer putBuffer(buf)
+func textFormatter(flags []ess.FmtFlagPart, entry *Entry) []byte {
+	buf := acquireBuffer()
+	defer releaseBuffer(buf)
 
-	for _, part := range *flags {
+	for _, part := range flags {
 		switch part.Flag {
 		case FmtFlagLevel:
 			buf.WriteString(fmt.Sprintf(part.Format, levelToLevelName[entry.Level]))
@@ -101,7 +99,7 @@ func textFormatter(flags *[]FlagPart, entry *Entry) []byte {
 			}
 			buf.WriteString(fmt.Sprintf(part.Format, entry.File))
 		case FmtFlagLine:
-			buf.WriteString(fmt.Sprintf(part.Format, entry.Line))
+			buf.WriteString("L" + fmt.Sprintf(part.Format, entry.Line))
 		case FmtFlagMessage:
 			buf.WriteString(entry.Message)
 		case FmtFlagCustom:
@@ -127,47 +125,11 @@ func jsonFormatter(entry *Entry) ([]byte, error) {
 // Unexported methods
 //___________________________________
 
-func applyFormatter(formatter string, flags *[]FlagPart, entry *Entry) []byte {
+func applyFormatter(formatter string, flags []ess.FmtFlagPart, entry *Entry) []byte {
 	if formatter == textFmt {
 		return textFormatter(flags, entry)
 	}
 
 	lm, _ := jsonFormatter(entry)
 	return lm
 }
-
-// parseFlag it parses the log message formart into flag parts
-//  For e.g.:
-//    %time:2006-01-02 15:04:05.000 %level %custom:- %msg
-func parseFlag(format string) (*[]FlagPart, error) {
-	var flagParts []FlagPart
-	format = strings.TrimSpace(format)
-	formatFlags := strings.Split(format, flagSeparator)[1:]
-	for _, f := range formatFlags {
-		parts := strings.SplitN(strings.TrimSpace(f), flagValueSeparator, 2)
-		flag := fmtFlagByName(parts[0])
-		if flag == FmtFlagUnknown {
-			return nil, fmt.Errorf("unrecognized log format flag: %v", strings.TrimSpace(f))
-		}
-
-		part := FlagPart{Flag: flag, Name: parts[0]}
-		switch len(parts) {
-		case 2:
-			if flag == FmtFlagTime || flag == FmtFlagUTCTime ||
-				flag == FmtFlagCustom {
-				part.Format = parts[1]
-			} else {
-				part.Format = "%" + parts[1] + "v"
-			}
-		default:
-			part.Format = defaultFormat
-			if flag == FmtFlagLine {
-				part.Format = "L" + defaultFormat
-			}
-		}
-
-		flagParts = append(flagParts, part)
-	}
-
-	return &flagParts, nil
-}

log.go

@@ -56,10 +56,7 @@ var (
 	// ErrLogReceiverIsNil returned when suppiled receiver is nil.
 	ErrLogReceiverIsNil = errors.New("log: receiver is nil")
 
-	flagSeparator      = "%"
-	flagValueSeparator = ":"
-	defaultFormat      = "%v"
-	filePermission     = os.FileMode(0755)
+	filePermission = os.FileMode(0755)
 
 	// abstract it, can be unit tested
 	exit = os.Exit
@@ -318,8 +315,8 @@ func (l *Logger) output(level level, calldepth int, format *string, v ...interfa
 		return
 	}
 
-	entry := getEntry()
-	defer putEntry(entry)
+	entry := acquireEntry()
+	defer releaseEntry(entry)
 	entry.Time = time.Now()
 	entry.Level = level
 	if format == nil {

util.go

@@ -8,6 +8,8 @@ import (
 	"runtime"
 	"strings"
 	"time"
+
+	"aahframework.org/essentials.v0-unstable"
 )
 
 var (
@@ -44,16 +46,16 @@ func levelByName(name string) level {
 	return LevelUnknown
 }
 
-func fmtFlagByName(name string) fmtFlag {
+func fmtFlagByName(name string) ess.FmtFlag {
 	if flag, ok := FmtFlags[name]; ok {
 		return flag
 	}
 
 	return FmtFlagUnknown
 }
 
-func isFmtFlagExists(flags *[]FlagPart, flag fmtFlag) bool {
-	for _, f := range *flags {
+func isFmtFlagExists(flags []ess.FmtFlagPart, flag ess.FmtFlag) bool {
+	for _, f := range flags {
 		if f.Flag == flag {
 			return true
 		}
@@ -71,7 +73,7 @@ func fetchCallerInfo(calldepth int) (string, int) {
 }
 
 // isCallerInfo method to identify to fetch caller or not.
-func isCallerInfo(flags *[]FlagPart) bool {
+func isCallerInfo(flags []ess.FmtFlagPart) bool {
 	return (isFmtFlagExists(flags, FmtFlagShortfile) ||
 		isFmtFlagExists(flags, FmtFlagLongfile) ||
 		isFmtFlagExists(flags, FmtFlagLine))