develop successful v1.1.6🚀

Author: auula

async.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2020 HigKer
+// Open Source: MIT License
+// Author: SDing <deen.job@qq.com>
+// Date: 2020/5/1 - 12:53 上午
+
+package logker
+
+
+const (
+	// Log message format wildcards
+	// {level} == logging level
+	// {time} == time
+	// {position} == runtime caller info
+	// {message} == logging message
+	// OutPut: [INFO] 2006-01-02 13:05.0006 MP - Position: test.go|main.test:21 - Message: news
+	DefaultFormat = "{level} - Date: {time}  {position} - Message: {message}" //This was modified for v 1.1.5
+)
+
+type Async interface {
+	sendMsg(msg *message)
+	begin()
+}
+
+type AsyncTask struct {
+	queueSize int64
+	logQueue  chan *message
+}
+
+// Initializes The Producer Channel Buffer
+func InitAsync(queueSize int64) *AsyncTask {
+	return &AsyncTask{queueSize: queueSize, logQueue: make(chan *message, queueSize)}
+}

async_console.go

@@ -0,0 +1,69 @@
+// Copyright (c) 2020 HigKer
+// Open Source: MIT License
+// Author: SDing <deen.job@qq.com>
+// Date: 2020/4/30 - 9:16 下午
+
+package logker
+
+import (
+	"github.com/fatih/color"
+	"strings"
+)
+
+// Channel Buffer Size
+const (
+	_    = iota
+	Qs1w = 10000 * iota
+	Qs2w
+	Qs3w
+	Qs4w
+	Qs5w
+	Qs6w
+)
+
+// send pack msg to log queue
+func (c *console) sendMsg(msg *message) {
+	c.asyncTask.logQueue <- msg
+}
+
+func (c *console) begin() {
+	go c.asyncOutPutTask()
+}
+
+func (c *console) asyncOutPutTask() {
+	for {
+		msg := <-c.asyncTask.logQueue
+		switch msg.level {
+		case DEBUG:
+			// blue color of log message.
+			// format log message output console.
+			color.Blue(c.parsePacket(msg))
+		case INFO:
+			color.Green(c.parsePacket(msg))
+		case WARNING:
+			color.Yellow(c.parsePacket(msg))
+		case ERROR:
+			color.Red(c.parsePacket(msg))
+		default:
+			// Log Level Type Error
+			// Program automatically set to debug
+			color.Red("-----------------------------------------------------------------")
+			color.Red("！！！Log Level Type Error,Program automatically set to debug！！！")
+			color.Red("-----------------------------------------------------------------")
+			c.logLevel = DEBUG
+			// recursion
+			c.sendMsg(c.pack(ERROR,"Log Level Type Error,Program automatically set to debug！！！"))
+		}
+	}
+}
+
+// ReplaceOurCustomMessageFormatIdentifier
+// This function was added at 23:50:28 on April 19, 2020 in v1.1.5
+func (c *console) parsePacket(msg *message) string {
+	str := msg.format
+	str = strings.Replace(str, "{level}", msg.level.toStr(), -1)
+	str = strings.Replace(str, "{time}", msg.logTime, -1)
+	str = strings.Replace(str, "{position}", msg.caller, -1)
+	str = strings.Replace(str, "{message}", msg.msg, -1)
+	return str + "\n"
+}

async_record_test.go renamed to async_console_test.go

@@ -0,0 +1,62 @@
+// Copyright (c) 2020 HigKer
+// Open Source: MIT License
+// Author: SDing <deen.job@qq.com>
+// Date: 2020/5/1 - 1:04 上午
+
+package logker
+
+import (
+	"strings"
+)
+
+const (
+	// Log file size
+	// You can also customize. Unit is kb.
+	MB10  int64 = 10 * 1024 * 1024
+	MB100 int64 = 100 * 1024 * 1024
+	GB1   int64 = 10 * MB100
+)
+
+// send pack msg to log queue
+func (f *fileLog) sendMsg(msg *message) {
+	f.asyncTask.logQueue <- msg
+}
+
+func (f *fileLog) begin() {
+	go f.asyncOutPutTask()
+}
+
+func (f *fileLog) asyncOutPutTask() {
+	for {
+		msg := <-f.asyncTask.logQueue
+		if f.checkSize() {
+			// division file
+			f.divisionLogFile(plain)
+		}
+		_, _ = f.file.WriteString(f.parsePacket(msg))
+		// 如果是error单独文件开启就执行
+		// zh_CN:	检测error独立文件输出开关是否开启 如果开启就往error独立文件输出内容
+		// usa_EN:	Check whether the error independent file output switch is turned on.
+		// If it is turned on, output the content to the error independent file
+		if msg.level == ERROR {
+			if f.checkErrSize() {
+				// division error file
+				f.divisionLogFile(major)
+			}
+			if f.isEnableErr() {
+				_, _ = f.errFile.WriteString(f.parsePacket(msg))
+			}
+		}
+	}
+}
+
+// ReplaceOurCustomMessageFormatIdentifier
+// This function was added at 23:50:28 on April 19, 2020 in v1.1.5
+func (f *fileLog) parsePacket(msg *message) string {
+	str := msg.format
+	str = strings.Replace(str, "{level}", msg.level.toStr(), -1)
+	str = strings.Replace(str, "{time}", msg.logTime, -1)
+	str = strings.Replace(str, "{position}", msg.caller, -1)
+	str = strings.Replace(str, "{message}", msg.msg, -1)
+	return str + "\n"
+}

async_file.go

@@ -13,7 +13,7 @@ import (
 
 // Runtime caller skip
 const (
-	SKIP = 2
+	SKIP = 1
 )
 
 func buildCallerStr(skip int) string {

async_record.go

@@ -9,7 +9,6 @@ import (
 	"errors"
 	"fmt"
 	"strings"
-	"testing"
 )
 
 // console Logger
@@ -27,24 +26,7 @@ type console struct {
 	asyncTask  *AsyncTask
 }
 
-// Build console Logger
-func NewClog(lev level, zone logTimeZone, formatting string, at *AsyncTask, t *testing.T) (Logger, error) {
-	consoleLog := &console{
-		// Level: logger Level
-		logLevel: lev,
-		// Zone : logger Time Zone
-		timeZone:  zone,
-		tz:        nil,
-		asyncTask: at,
-	}
-	if err := verify(formatting); err != nil {
-		return nil, err
-	}
-	consoleLog.formatting = formatting
-	consoleLog.initTime()
-	consoleLog.asyncTask.begin(t)
-	return consoleLog, nil
-}
+
 
 func (c *console) initTime() {
 	// set customize time zone
@@ -59,22 +41,22 @@ func (c *console) isEnableLevel(lev level) bool {
 
 func (c *console) Info(value string, args ...interface{}) {
 	if c.isEnableLevel(INFO) {
-		c.asyncTask.sendMsg(c.pack(INFO, fmt.Sprintf(value, args...)))
+		c.sendMsg(c.pack(INFO, fmt.Sprintf(value, args...)))
 	}
 }
 func (c *console) Debug(value string, args ...interface{}) {
 	if c.isEnableLevel(DEBUG) {
-		c.asyncTask.sendMsg(c.pack(DEBUG, fmt.Sprintf(value, args...)))
+		c.sendMsg(c.pack(DEBUG, fmt.Sprintf(value, args...)))
 	}
 }
 func (c *console) Error(value string, args ...interface{}) {
 	if c.isEnableLevel(ERROR) {
-		c.asyncTask.sendMsg(c.pack(ERROR, fmt.Sprintf(value, args...)))
+		c.sendMsg(c.pack(ERROR, fmt.Sprintf(value, args...)))
 	}
 }
 func (c *console) Warning(value string, args ...interface{}) {
 	if c.isEnableLevel(WARNING) {
-		c.asyncTask.sendMsg(c.pack(WARNING, fmt.Sprintf(value, args...)))
+		c.sendMsg(c.pack(WARNING, fmt.Sprintf(value, args...)))
 	}
 }
 

caller.go

@@ -18,8 +18,8 @@ func TestVerifyString(t *testing.T) {
 
 func TestConsole_Debug(t *testing.T) {
 	defaults := "{level} - Date: {time}  {position} - Message: {message}"
-	task := InitAsyncTask(Qs1w)
-	logger, e := NewClog(ERROR, Shanghai, defaults, task, t)
+	task := InitAsync(Qs1w)
+	logger, e := NewClog(ERROR, Shanghai, defaults, task)
 	if e != nil {
 		t.Log(e)
 	}