go語言紀錄檔實現詳解(列印紀錄檔、紀錄檔寫入檔案和紀錄檔切割)

2022-10-30 14:00:18

Go語言內建的log包實現了簡單的紀錄檔服務
Logger
標準logger的設定
設定紀錄檔字首（SetPrefix）
設定紀錄檔輸出位置
建立新logger物件
紀錄檔庫級別
runtime.Caller
可變引數的紀錄檔
實現往檔案裡面寫紀錄檔
紀錄檔切割（按檔案大小切割、按日期切割）
總結

Go語言內建的log包實現了簡單的紀錄檔服務

Logger

package main

import (
	"log"
)

func main() {
	log.Println("這是一條測試的紀錄檔。")
	v := "很普通的"
	log.Printf("這是一條%s紀錄檔。n", v)
	log.Fatalln("這是一條會觸發fatal的紀錄檔。")
	log.Panicln("這是一條會觸發panic的紀錄檔。")
}

標準logger的設定

SetFlags函數用來設定標準logger的輸出設定。

const (
    // 控制輸出紀錄檔資訊的細節，不能控制輸出的順序和格式。
    // 輸出的紀錄檔在每一項後會有一個冒號分隔：例如2009/01/23 01:23:23.123123 /a/b/c/d.go:23: message
    Ldate         = 1 << iota     // 日期：2009/01/23
    Ltime                         // 時間：01:23:23
    Lmicroseconds                 // 微秒級別的時間：01:23:23.123123（用於增強Ltime位）
    Llongfile                     // 檔案全路徑名+行號： /a/b/c/d.go:23
    Lshortfile                    // 檔名+行號：d.go:23（會覆蓋掉Llongfile）
    LUTC                          // 使用UTC時間
    LstdFlags     = Ldate | Ltime // 標準logger的初始值
)

func main() {
	log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
	log.Println("這是一條很普通的紀錄檔。")
}

設定紀錄檔字首（SetPrefix）

func main() {
	log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
	log.Println("這是一條很普通的紀錄檔。")
	log.SetPrefix("[哈哈哈]")
	log.Println("這是一條很普通的紀錄檔。")
}

設定紀錄檔輸出位置

SetOutput函數用來設定標準logger的輸出目的地，預設是標準錯誤輸出。

func init() {
	logFile, err := os.OpenFile("./xx.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		fmt.Println("open log file failed, err:", err)
		return
	}
	log.SetOutput(logFile)
	log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
}

建立新logger物件

log標準庫中還提供了一個建立新logger物件的建構函式–New，支援我們建立自己的logger範例。New函數的簽名如下：

func New(out io.Writer, prefix string, flag int) *Logger

New建立一個Logger物件。其中，引數out設定紀錄檔資訊寫入的目的地。引數prefix會新增到生成的每一條紀錄檔前面。引數flag定義紀錄檔的屬性（時間、檔案等等）。

舉個例子：

func main() {
	logger := log.New(os.Stdout, "<New>", log.Lshortfile|log.Ldate|log.Ltime)
	logger.Println("這是自定義的logger記錄的紀錄檔。")
}
//<New>2017/06/19 14:06:51 main.go:34: 這是自定義的logger記錄的紀錄檔。

補充：Go內建的log庫功能有限，例如無法滿足記錄不同級別紀錄檔的情況，需要選擇使用第三方的紀錄檔庫，如logrus、zap等。

紀錄檔庫級別

package log

import (
	"errors"
	"fmt"
	"strings"
	"time"
)

type LogLevel uint16

//紀錄檔常數
const (
	UNKNOW LogLevel = iota
	DEBUG 
	TRACE
	INFO
	WARNIG
	ERROR
	FATAL

)
//解析紀錄檔級別
func paraLogLevel(s string) (LogLevel,error) {
	s = strings.ToLower(s)
	switch s {

	case "debug":
		return DEBUG,nil

	case "tarce":
		return TRACE,nil
	case "info":
		return INFO,nil
	case "warnig":
		return WARNIG,nil
	case "error":
		return ERROR,nil
	case "fatal":
		return FATAL,nil
	default:
		err:= errors.New("無效的紀錄檔級別")
		return UNKNOW,err
	}
}
//定義紀錄檔級別機構提
type Logger  struct{
	Level LogLevel
}
//構造器
func NewLog(levelLog string) Logger  {
	level, err := paraLogLevel(levelLog)
	if err !=nil{
		panic(err)
	}
	return Logger{
		Level: level,
	}
}
//是否能夠列印某個級別的紀錄檔
func (l Logger)  enable(logLevel LogLevel) bool {
		return l.Level >logLevel
}

func (l Logger) Debug(msg string) {
	if l.enable(DEBUG){
		now := time.Now()
		fmt.Printf("[%s] [Debug] %s",now.Format("2006-01-02 15:04:05"),msg);
	}

}

func (l Logger) Info(msg string) {
	if l.enable(INFO){
		now := time.Now()
		fmt.Printf("[%s] [Info] %s",now.Format("2006-01-02 15:04:05"),msg);
	}

}

func (l Logger) Warning(msg string) {
	if l.enable(WARNIG){
		now := time.Now()
		fmt.Printf("[%s] [Warning] %s",now.Format("2006-01-02 15:04:05"),msg);
	}

}

func (l Logger) Error(msg string) {
	if l.enable(ERROR){
		now := time.Now()
		fmt.Printf("[%s] [Error] %s",now.Format("2006-01-02 15:04:05"),msg);
	}

}

func (l Logger) Fatal(msg string) {
	if l.enable(FATAL){
		now := time.Now()
		fmt.Printf("[%s] [Fatal] %s",now.Format("2006-01-02 15:04:05"),msg);
	}

}

import "gostudy/log"

func main()  {

	newLog := log.NewLog("warnig")
	newLog.Debug("這是debug紀錄檔")
	newLog.Info("這是info紀錄檔")
	newLog.Warning("這是Warning紀錄檔")
	newLog.Error("這是ERROR紀錄檔")
	newLog.Fatal("這是FATAL紀錄檔")
}

列印結果：[2022-08-04 10:41:56] [Debug] 這是debug紀錄檔[2022-08-04 10:41:56] [Info] 這是info紀錄檔

runtime.Caller

能夠拿到檔名函數名和行號

可變引數的紀錄檔

//......interface{}表示可變的任意引數，可不傳也可傳任意長度
func (l Logger) Debug(msg string, a ...interface{}) {
	msg = fmt.Sprint(msg,a)
	if l.enable(DEBUG){
		now := time.Now()
		fmt.Printf("[%s] [Debug] %s",now.Format("2006-01-02 15:04:05"),msg);
	}

}

實現往檔案裡面寫紀錄檔

1.新建fileloger.go檔案，用來提供寫入紀錄檔的功能

package log

import (
	"errors"
	"fmt"
	"os"
	"path"
	"strings"
	"time"
)

type LogLevel uint16
//紀錄檔級別
const (
	UNKNOW LogLevel = iota
	DEBUG 
	TRACE
	INFO
	WARNIG
	ERROR
	FATAL

)
//解析紀錄檔
func paraLogLevel(s string) (LogLevel,error) {
	s = strings.ToLower(s)
	switch s {

	case "debug":
		return DEBUG,nil

	case "tarce":
		return TRACE,nil
	case "info":
		return INFO,nil
	case "warnig":
		return WARNIG,nil
	case "error":
		return ERROR,nil
	case "fatal":
		return FATAL,nil
	default:
		err:= errors.New("無效的紀錄檔級別")
		return UNKNOW,err
	}
}

//獲取紀錄檔的字串格式
func getLogStr (level LogLevel) string {

	switch level {

	case DEBUG:
		return "debug"

	case TRACE:
		return "tarce"
	case INFO:
		return "info"
	case WARNIG:
		return "warnig"
	case ERROR:
		return "error"
	case FATAL:
		return "fatal"
	default:
		return "unknow"
	}
}

//定義紀錄檔的結構體
type FileLogger  struct{
	Level LogLevel
	filePath string
	fileName string
	//要開啟和寫入的檔案，一個紀錄檔檔案一個錯誤紀錄檔檔案
	fileObj *os.File
	errfileObj *os.File
	maxFileSize int64
}

//建構函式
func NewFlieLogger(LeveStr ,fp,fn string,size int64)  *FileLogger{

	level, err := paraLogLevel(LeveStr)
	if err != nil {
		panic(err)
	}
	f1 := &FileLogger{
		Level: level,
		filePath: fp,
		fileName: fn,
		maxFileSize: size,
	}
	err= f1.initFile()
	if err != nil {
		panic(err)
	}
	return f1
}

//初始化要開啟和寫入的紀錄檔檔案的操作
func (f *FileLogger) initFile() (error) {
	join := path.Join(f.filePath, f.fileName)
	fileObj, err := os.OpenFile(join, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Printf("open log fail ,err: %vn",err)
		return err
	}

	errFileObj, err := os.OpenFile(join+".err", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Printf("open log fail ,err: %vn",err)
		return err
	}
	//紀錄檔檔案都開啟
	f.fileObj = fileObj;
	f.errfileObj = errFileObj;
	return  nil

}
//判斷級別
func (l FileLogger)  enable(logLevel LogLevel) bool {
		return l.Level >logLevel
}
//列印紀錄檔操作
func (f *FileLogger) Log(leve LogLevel,msg string)  {
	now := time.Now()
	if f.enable(leve){

		fmt.Fprintf(f.fileObj,"[%s] [%s] %s",now.Format("2006-01-02 15:04:05"),getLogStr(leve),msg);
	}

	if leve >ERROR{

		fmt.Fprintf(f.errfileObj,"[%s] [%s] %s",now.Format("2006-01-02 15:04:05"),getLogStr(leve),msg);
	}
}

func (l FileLogger) Debug(msg string, a ...interface{}) {
	msg = fmt.Sprint(msg,a)
	if l.enable(DEBUG){
		l.Log(DEBUG,msg)
	}

}

func (l FileLogger) Info(msg string, a ...interface{}) {
	msg = fmt.Sprint(msg,a)
	if l.enable(WARNIG){
		l.Log(WARNIG,msg)
	}

}


func (l FileLogger) Warning(msg string, a ...interface{}) {
	msg = fmt.Sprint(msg,a)
	if l.enable(WARNIG){
		l.Log(WARNIG,msg)
	}

}

func (l FileLogger) Error(msg string, a ...interface{}) {
	msg = fmt.Sprint(msg,a)
	if l.enable(ERROR){
		l.Log(ERROR,msg)
	}

}

func (l FileLogger) Fatal(msg string, a ...interface{}) {
	msg = fmt.Sprint(msg,a)
	if l.enable(FATAL){
		l.Log(FATAL,msg)
	}

}

func (f *FileLogger) Colse()  {
	f.fileObj.Close()
	f.errfileObj.Close()
}

2.測試：

func main()  {

	newLog := log.NewFlieLogger("warnig","./","now.log",100*1024*1024)
	newLog.Debug("這是debug紀錄檔")
	newLog.Info("這是info紀錄檔")
	newLog.Warning("這是Warning紀錄檔")
	newLog.Error("這是ERROR紀錄檔")
	newLog.Fatal("這是FATAL紀錄檔")
	newLog.Colse()

}

//執行兩次後，列印結果：

紀錄檔切割（按檔案大小切割、按日期切割）

其實就是每次記錄檔案的大小，超過了就重新寫一個檔案。

通過Stat()函數拿到檔案的一些資訊

	open, _:= os.Open("檔名")
	stat, _， := open.Stat()
	stat.Size()//拿到檔案大小

日期切割：

拿到檔案的名稱或者檢查下有沒有當天的紀錄檔檔案，沒有就建立新增。

總結

到此這篇關於go語言紀錄檔實現(列印紀錄檔、紀錄檔寫入檔案和紀錄檔切割)的文章就介紹到這了,更多相關go語言列印紀錄檔和紀錄檔切割內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！