feat:新增logger包

logger/logger.go

@@ -0,0 +1,653 @@
+package logger
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"regexp"
+	"runtime/debug"
+	"sort"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+/***
+author:donnie email donnie4w@gmail.com
+在控制台打印：直接调用 Debug(***) Info(***) Warn(***) Error(***) Fatal(***)
+可以设置打印格式：SetFormat(FORMAT_SHORTFILENAME|FORMAT_DATE|FORMAT_TIME)
+	无其他格式，只打印日志内容
+	FORMAT_NANO
+	长文件名及行数
+	FORMAT_LONGFILENAME
+	短文件名及行数
+	FORMAT_SHORTFILENAME
+	精确到日期
+	FORMAT_DATE
+	精确到秒
+	FORMAT_TIME
+	精确到微秒
+	FORMAT_MICROSECNDS
+	—————————————————————————————————————————————————————————————————————
+    写日志文件可以获取实例
+    全局实例可以直接调用log := logging.GetStaticLogger()
+    获取新实例可以调用log := logging.NewLogger()
+	1. 按日期分割日志文件
+    	log.SetRollingDaily("d://foldTest", "log.txt")
+	2. 按文件大小分割日志文件
+	log.SetRollingFile("d://foldTest", "log.txt", 300, MB)
+	log.SetConsole(false)控制台不打日志,默认值true
+    日志级别
+***/
+
+const (
+	_VER string = "1.0.1"
+)
+
+type _LEVEL int8
+type _UNIT int64
+type _MODE_TIME uint8
+type _ROLLTYPE int //dailyRolling ,rollingFile
+type _FORMAT int
+
+const _DATEFORMAT_DAY = "20060102"
+const _DATEFORMAT_HOUR = "2006010215"
+const _DATEFORMAT_MONTH = "200601"
+
+var static_mu *sync.Mutex = new(sync.Mutex)
+
+var static_lo *_logger = NewLogger()
+
+const (
+	_        = iota
+	KB _UNIT = 1 << (iota * 10)
+	MB
+	GB
+	TB
+)
+
+const (
+	MODE_HOUR  _MODE_TIME = 1
+	MODE_DAY   _MODE_TIME = 2
+	MODE_MONTH _MODE_TIME = 3
+)
+
+const (
+	/*无其他格式，只打印日志内容*/
+	FORMAT_NANO _FORMAT = 0
+	/*长文件名及行数*/
+	FORMAT_LONGFILENAME = _FORMAT(log.Llongfile)
+	/*短文件名及行数*/
+	FORMAT_SHORTFILENAME = _FORMAT(log.Lshortfile)
+	/*日期时间精确到天*/
+	FORMAT_DATE = _FORMAT(log.Ldate)
+	/*时间精确到秒*/
+	FORMAT_TIME = _FORMAT(log.Ltime)
+	/*时间精确到微秒*/
+	FORMAT_MICROSECNDS = _FORMAT(log.Lmicroseconds)
+)
+
+const (
+	/*日志级别：ALL 最低级别*/
+	LEVEL_ALL _LEVEL = iota
+	/*日志级别：DEBUG 小于INFO*/
+	LEVEL_DEBUG
+	/*日志级别：INFO 小于 WARN*/
+	LEVEL_INFO
+	/*日志级别：WARN 小于 ERROR*/
+	LEVEL_WARN
+	/*日志级别：ERROR 小于 FATAL*/
+	LEVEL_ERROR
+	/*日志级别：FATAL 小于 OFF*/
+	LEVEL_FATAL
+	/*日志级别：off 不打印任何日志*/
+	LEVEL_OFF
+)
+
+const (
+	_DAYLY _ROLLTYPE = iota
+	_ROLLFILE
+)
+
+var default_format _FORMAT = FORMAT_SHORTFILENAME | FORMAT_DATE | FORMAT_TIME
+var default_level = LEVEL_ALL
+
+/*设置打印格式*/
+func SetFormat(format _FORMAT) {
+	default_format = format
+	static_lo.SetFormat(format)
+
+}
+
+/*设置控制台日志级别，默认ALL*/
+func SetLevel(level _LEVEL) {
+	default_level = level
+	static_lo.SetLevel(level)
+}
+
+func SetConsole(on bool) {
+	static_lo.SetConsole(on)
+}
+
+/*获得全局Logger对象*/
+func GetStaticLogger() *_logger {
+	return _staticLogger()
+}
+
+func SetRollingFile(fileDir, fileName string, maxFileSize int64, unit _UNIT) (err error) {
+	return SetRollingFileLoop(fileDir, fileName, maxFileSize, unit, 0)
+}
+
+func SetRollingDaily(fileDir, fileName string) (err error) {
+	return SetRollingByTime(fileDir, fileName, MODE_DAY)
+}
+
+func SetRollingFileLoop(fileDir, fileName string, maxFileSize int64, unit _UNIT, maxFileNum int) (err error) {
+	return static_lo.SetRollingFileLoop(fileDir, fileName, maxFileSize, unit, maxFileNum)
+}
+
+func SetRollingByTime(fileDir, fileName string, mode _MODE_TIME) (err error) {
+	return static_lo.SetRollingByTime(fileDir, fileName, mode)
+}
+
+func _staticLogger() *_logger {
+	return static_lo
+}
+
+func Debug(v ...interface{}) {
+	_print(default_format, LEVEL_DEBUG, default_level, 2, v...)
+}
+func Info(v ...interface{}) {
+	_print(default_format, LEVEL_INFO, default_level, 2, v...)
+}
+func Warn(v ...interface{}) {
+	_print(default_format, LEVEL_WARN, default_level, 2, v...)
+}
+func Error(v ...interface{}) {
+	_print(default_format, LEVEL_ERROR, default_level, 2, v...)
+}
+func Fatal(v ...interface{}) {
+	_print(default_format, LEVEL_FATAL, default_level, 2, v...)
+}
+
+func _print(_format _FORMAT, level, _default_level _LEVEL, calldepth int, v ...interface{}) {
+	if level < _default_level {
+		return
+	}
+	_staticLogger().println(level, k1(calldepth), v...)
+}
+
+func __print(_format _FORMAT, level, _default_level _LEVEL, calldepth int, v ...interface{}) {
+	_console(formatV(v...), getlevelname(level, default_format), _format, k1(calldepth))
+}
+
+func getlevelname(level _LEVEL, format _FORMAT) (levelname string) {
+	if format == FORMAT_NANO {
+		return
+	}
+	switch level {
+	case LEVEL_ALL:
+		levelname = "[ALL]"
+	case LEVEL_DEBUG:
+		levelname = "[DEBUG]"
+	case LEVEL_INFO:
+		levelname = "[INFO]"
+	case LEVEL_WARN:
+		levelname = "[WARN]"
+	case LEVEL_ERROR:
+		levelname = "[ERROR]"
+	case LEVEL_FATAL:
+		levelname = "[FATAL]"
+	default:
+	}
+	return
+}
+
+/*————————————————————————————————————————————————————————————————————————————*/
+type _logger struct {
+	_level      _LEVEL
+	_format     _FORMAT
+	_rwLock     *sync.RWMutex
+	_safe       bool
+	_fileDir    string
+	_fileName   string
+	_maxSize    int64
+	_unit       _UNIT
+	_rolltype   _ROLLTYPE
+	_mode       _MODE_TIME
+	_fileObj    *fileObj
+	_maxFileNum int
+	_isConsole  bool
+}
+
+func NewLogger() (log *_logger) {
+	log = &_logger{_level: LEVEL_DEBUG, _rolltype: _DAYLY, _rwLock: new(sync.RWMutex), _format: FORMAT_SHORTFILENAME | FORMAT_DATE | FORMAT_TIME, _isConsole: true}
+	log.newfileObj()
+	return
+}
+
+//控制台日志是否打开
+func (this *_logger) SetConsole(_isConsole bool) {
+	this._isConsole = _isConsole
+}
+func (this *_logger) Debug(v ...interface{}) {
+	this.println(LEVEL_DEBUG, 2, v...)
+}
+func (this *_logger) Info(v ...interface{}) {
+	this.println(LEVEL_INFO, 2, v...)
+}
+func (this *_logger) Warn(v ...interface{}) {
+	this.println(LEVEL_WARN, 2, v...)
+}
+func (this *_logger) Error(v ...interface{}) {
+	this.println(LEVEL_ERROR, 2, v...)
+}
+func (this *_logger) Fatal(v ...interface{}) {
+	this.println(LEVEL_FATAL, 2, v...)
+}
+func (this *_logger) SetFormat(format _FORMAT) {
+	this._format = format
+}
+func (this *_logger) SetLevel(level _LEVEL) {
+	this._level = level
+}
+
+/*按日志文件大小分割日志文件
+fileDir 日志文件夹路径
+fileName 日志文件名
+maxFileSize  日志文件大小最大值
+unit    日志文件大小单位
+*/
+func (this *_logger) SetRollingFile(fileDir, fileName string, maxFileSize int64, unit _UNIT) (err error) {
+	return this.SetRollingFileLoop(fileDir, fileName, maxFileSize, unit, 0)
+}
+
+/*按日志文件大小分割日志文件，指定保留的最大日志文件数
+fileDir 日志文件夹路径
+fileName 日志文件名
+maxFileSize  日志文件大小最大值
+unit    	日志文件大小单位
+maxFileNum  留的日志文件数
+*/
+func (this *_logger) SetRollingFileLoop(fileDir, fileName string, maxFileSize int64, unit _UNIT, maxFileNum int) (err error) {
+	if fileDir == "" {
+		fileDir, _ = os.Getwd()
+	}
+	if maxFileNum > 0 {
+		maxFileNum--
+	}
+	this._fileDir, this._fileName, this._maxSize, this._maxFileNum, this._unit = fileDir, fileName, maxFileSize, maxFileNum, unit
+	this._rolltype = _ROLLFILE
+	if this._fileObj != nil {
+		this._fileObj.close()
+	}
+	this.newfileObj()
+	err = this._fileObj.openFileHandler()
+	return
+}
+
+/*按日期分割日志文件
+fileDir 日志文件夹路径
+fileName 日志文件名
+*/
+func (this *_logger) SetRollingDaily(fileDir, fileName string) (err error) {
+	return this.SetRollingByTime(fileDir, fileName, MODE_DAY)
+}
+
+/*指定按 小时，天，月 分割日志文件
+fileDir 日志文件夹路径
+fileName 日志文件名
+mode   指定 小时，天，月
+*/
+func (this *_logger) SetRollingByTime(fileDir, fileName string, mode _MODE_TIME) (err error) {
+	if fileDir == "" {
+		fileDir, _ = os.Getwd()
+	}
+	this._fileDir, this._fileName, this._mode = fileDir, fileName, mode
+	this._rolltype = _DAYLY
+	if this._fileObj != nil {
+		this._fileObj.close()
+	}
+	this.newfileObj()
+	err = this._fileObj.openFileHandler()
+	return
+}
+
+func (this *_logger) newfileObj() {
+	this._fileObj = new(fileObj)
+	this._fileObj._fileDir, this._fileObj._fileName, this._fileObj._maxSize, this._fileObj._rolltype, this._fileObj._unit, this._fileObj._maxFileNum, this._fileObj._mode = this._fileDir, this._fileName, this._maxSize, this._rolltype, this._unit, this._maxFileNum, this._mode
+}
+
+func (this *_logger) backUp() (err, openFileErr error) {
+	this._rwLock.Lock()
+	defer this._rwLock.Unlock()
+	if !this._fileObj.isMustBackUp() {
+		return
+	}
+	err = this._fileObj.close()
+	if err != nil {
+		__print(this._format, LEVEL_ERROR, LEVEL_ERROR, 1, err.Error())
+		return
+	}
+	err = this._fileObj.rename()
+	if err != nil {
+		__print(this._format, LEVEL_ERROR, LEVEL_ERROR, 1, err.Error())
+		return
+	}
+	openFileErr = this._fileObj.openFileHandler()
+	if openFileErr != nil {
+		__print(this._format, LEVEL_ERROR, LEVEL_ERROR, 1, openFileErr.Error())
+	}
+	return
+}
+
+func (this *_logger) println(_level _LEVEL, calldepth int, v ...interface{}) {
+	if this._level > _level {
+		return
+	}
+	if this._fileObj._isFileWell {
+		var openFileErr error
+		if this._fileObj.isMustBackUp() {
+			_, openFileErr = this.backUp()
+		}
+		if openFileErr == nil {
+			func() {
+				this._rwLock.RLock()
+				defer this._rwLock.RUnlock()
+				buf := getOutBuffer(formatV(v...), getlevelname(_level, this._format), this._format, k1(calldepth)+1)
+				this._fileObj.write2file(buf.Bytes())
+			}()
+		}
+	}
+	if this._isConsole {
+		__print(this._format, _level, this._level, k1(calldepth), v...)
+	}
+}
+
+/*————————————————————————————————————————————————————————————————————————————*/
+type fileObj struct {
+	_fileDir     string
+	_fileName    string
+	_maxSize     int64
+	_fileSize    int64
+	_unit        _UNIT
+	_fileHandler *os.File
+	_rolltype    _ROLLTYPE
+	_tomorSecond int64
+	_isFileWell  bool
+	_maxFileNum  int
+	_mode        _MODE_TIME
+}
+
+func (this *fileObj) openFileHandler() (e error) {
+	if this._fileDir == "" || this._fileName == "" {
+		e = errors.New("log filePath is null or error")
+		return
+	}
+	e = mkdirDir(this._fileDir)
+	if e != nil {
+		this._isFileWell = false
+		return
+	}
+	fname := fmt.Sprint(this._fileDir, "/", this._fileName)
+	this._fileHandler, e = os.OpenFile(fname, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666)
+	if e != nil {
+		__print(default_format, LEVEL_ERROR, LEVEL_ERROR, 1, e.Error())
+		this._isFileWell = false
+		return
+	}
+	this._isFileWell = true
+	this._tomorSecond = tomorSecond(this._mode)
+	fs, err := this._fileHandler.Stat()
+	if err == nil {
+		this._fileSize = fs.Size()
+	} else {
+		e = err
+	}
+	return
+}
+
+func (this *fileObj) addFileSize(size int64) {
+	atomic.AddInt64(&this._fileSize, size)
+}
+
+func (this *fileObj) write2file(bs []byte) (e error) {
+	defer catchError()
+	if bs != nil {
+		this.addFileSize(int64(len(bs)))
+		_write2file(this._fileHandler, bs)
+	}
+	return
+}
+
+func (this *fileObj) isMustBackUp() bool {
+	switch this._rolltype {
+	case _DAYLY:
+		if time.Now().Unix() >= this._tomorSecond {
+			return true
+		}
+	case _ROLLFILE:
+		return this._fileSize > 0 && this._fileSize >= this._maxSize*int64(this._unit)
+	}
+	return false
+}
+
+func (this *fileObj) rename() (err error) {
+	bckupfilename := ""
+	if this._rolltype == _DAYLY {
+		bckupfilename = getBackupDayliFileName(this._fileDir, this._fileName, this._mode)
+	} else {
+		bckupfilename, err = getBackupRollFileName(this._fileDir, this._fileName)
+	}
+	if bckupfilename != "" && err == nil {
+		oldPath := fmt.Sprint(this._fileDir, "/", this._fileName)
+		newPath := fmt.Sprint(this._fileDir, "/", bckupfilename)
+		err = os.Rename(oldPath, newPath)
+		if err == nil && this._rolltype == _ROLLFILE && this._maxFileNum > 0 {
+			go _rmOverCountFile(this._fileDir, bckupfilename, this._maxFileNum)
+		}
+	}
+	return
+}
+
+func (this *fileObj) close() (err error) {
+	defer catchError()
+	if this._fileHandler != nil {
+		err = this._fileHandler.Close()
+	}
+	return
+}
+
+func tomorSecond(mode _MODE_TIME) int64 {
+	now := time.Now()
+	switch mode {
+	case MODE_DAY:
+		return time.Date(now.Year(), now.Month(), now.Day()+1, 0, 0, 0, 0, now.Location()).Unix()
+	case MODE_HOUR:
+		return time.Date(now.Year(), now.Month(), now.Day(), now.Hour()+1, 0, 0, 0, now.Location()).Unix()
+	case MODE_MONTH:
+		return time.Date(now.Year(), now.Month()+1, 0, 0, 0, 0, 0, now.Location()).AddDate(0, 0, 1).Unix()
+	default:
+		return time.Date(now.Year(), now.Month(), now.Day()+1, 0, 0, 0, 0, now.Location()).Unix()
+	}
+}
+
+func _yestStr(mode _MODE_TIME) string {
+	now := time.Now()
+	switch mode {
+	case MODE_DAY:
+		return now.AddDate(0, 0, -1).Format(_DATEFORMAT_DAY)
+	case MODE_HOUR:
+		return now.Add(-1 * time.Hour).Format(_DATEFORMAT_HOUR)
+	case MODE_MONTH:
+		return now.AddDate(0, -1, 0).Format(_DATEFORMAT_MONTH)
+	default:
+		return now.AddDate(0, 0, -1).Format(_DATEFORMAT_DAY)
+	}
+}
+
+/*————————————————————————————————————————————————————————————————————————————*/
+func getBackupDayliFileName(dir, filename string, mode _MODE_TIME) (bckupfilename string) {
+	timeStr := _yestStr(mode)
+	index := strings.LastIndex(filename, ".")
+	if index <= 0 {
+		index = len(filename)
+	}
+	fname := filename[:index]
+	suffix := filename[index:]
+	bckupfilename = fmt.Sprint(fname, "_", timeStr, suffix)
+	if isFileExist(fmt.Sprint(dir, "/", bckupfilename)) {
+		bckupfilename = _getBackupfilename(1, dir, fmt.Sprint(fname, "_", timeStr), suffix)
+	}
+	return
+}
+
+func _getDirList(dir string) ([]os.DirEntry, error) {
+	f, err := os.Open(dir)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	return f.ReadDir(-1)
+}
+
+func getBackupRollFileName(dir, filename string) (bckupfilename string, er error) {
+	list, err := _getDirList(dir)
+	if err != nil {
+		er = err
+		return
+	}
+	index := strings.LastIndex(filename, ".")
+	if index <= 0 {
+		index = len(filename)
+	}
+	fname := filename[:index]
+	suffix := filename[index:]
+	length := len(list)
+	bckupfilename = _getBackupfilename(length, dir, fname, suffix)
+	return
+}
+
+func _getBackupfilename(count int, dir, filename, suffix string) (bckupfilename string) {
+	bckupfilename = fmt.Sprint(filename, "_", count, suffix)
+	if isFileExist(fmt.Sprint(dir, "/", bckupfilename)) {
+		return _getBackupfilename(count+1, dir, filename, suffix)
+	}
+	return
+}
+
+func _write2file(f *os.File, bs []byte) (e error) {
+	_, e = f.Write(bs)
+	return
+}
+
+func _console(s string, levelname string, flag _FORMAT, calldepth int) {
+	buf := getOutBuffer(s, levelname, flag, k1(calldepth))
+	fmt.Print(&buf)
+}
+
+func outwriter(out io.Writer, prefix string, flag _FORMAT, calldepth int, s string) {
+	l := log.New(out, prefix, int(flag))
+	l.Output(k1(calldepth), s)
+}
+
+func k1(calldepth int) int {
+	return calldepth + 1
+}
+
+func getOutBuffer(s string, levelname string, flag _FORMAT, calldepth int) (buf bytes.Buffer) {
+	outwriter(&buf, levelname, flag, k1(calldepth), s)
+	return
+}
+
+func mkdirDir(dir string) (e error) {
+	_, er := os.Stat(dir)
+	b := er == nil || os.IsExist(er)
+	if !b {
+		if err := os.MkdirAll(dir, 0666); err != nil {
+			if os.IsPermission(err) {
+				e = err
+			}
+		}
+	}
+	return
+}
+
+func isFileExist(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil || os.IsExist(err)
+}
+
+func catchError() {
+	if err := recover(); err != nil {
+		Fatal(string(debug.Stack()))
+	}
+}
+
+func _rmOverCountFile(dir, backupfileName string, maxFileNum int) {
+	static_mu.Lock()
+	defer static_mu.Unlock()
+	f, err := os.Open(dir)
+	if err != nil {
+		return
+	}
+	dirs, _ := f.ReadDir(-1)
+	f.Close()
+	if len(dirs) <= maxFileNum {
+		return
+	}
+	sort.Slice(dirs, func(i, j int) bool {
+		f1, _ := dirs[i].Info()
+		f2, _ := dirs[j].Info()
+		return f1.ModTime().Unix() > f2.ModTime().Unix()
+	})
+	index := strings.LastIndex(backupfileName, "_")
+	indexSuffix := strings.LastIndex(backupfileName, ".")
+	if indexSuffix == 0 {
+		indexSuffix = len(backupfileName)
+	}
+	prefixname := backupfileName[:index+1]
+	suffix := backupfileName[indexSuffix:]
+	suffixlen := len(suffix)
+	rmfiles := make([]string, 0)
+	i := 0
+	for _, f := range dirs {
+		if len(f.Name()) > len(prefixname) && f.Name()[:len(prefixname)] == prefixname && _matchString("^[0-9]+$", f.Name()[len(prefixname):len(f.Name())-suffixlen]) {
+			finfo, err := f.Info()
+			if err == nil && !finfo.IsDir() {
+				i++
+				if i > maxFileNum {
+					rmfiles = append(rmfiles, fmt.Sprint(dir, "/", f.Name()))
+				}
+			}
+		}
+	}
+	if len(rmfiles) > 0 {
+		for _, k := range rmfiles {
+			os.Remove(k)
+		}
+	}
+}
+
+func _matchString(pattern string, s string) bool {
+	b, err := regexp.MatchString(pattern, s)
+	if err != nil {
+		b = false
+	}
+	return b
+}
+
+func formatV(v ...interface{}) string {
+	s := strings.Builder{}
+	for _, vv := range v {
+		if s.Len() > 0 {
+			s.WriteString(" ")
+		}
+		s.WriteString(fmt.Sprint(vv))
+	}
+	return s.String()
+}