Go语言中日志库demo

// logger.go
package logger

import "strings"

//日志库

//Loglevelmap 定义日志级别map
var Loglevelmap = map[string]int{
	"debug": 0,
	"info":  1,
	"warn":  2,
	"error": 3,
	"fatal": 4,
}

//Logger 是一个日志接口
type Logger interface {
	Debug(format string, args ...interface{})
	Info(format string, args ...interface{})
	Warn(format string, args ...interface{})
	Error(format string, args ...interface{})
	Fatal(format string, args ...interface{})
	Close()
}

// Getlevel 获取日志级别
func Getlevel(level string) int {
	//统一转成小写
	level = strings.ToLower(level)
	val, ok := Loglevelmap[level]
	if ok {
		return val
	}
	return 1
}

// file.go
package logger

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

// FileLogger 日志结构体
type FileLogger struct {
	Level    string
	Filepath string
	Filename string
	file     *os.File
	errFile  *os.File
	maxSize  int64
	lastTime time.Time
}

// NewFileLogger 构造日志结构体函数
func NewFileLogger(Level, Filepath, Filename string) *FileLogger {
	FileObj := &FileLogger{
		Level:    Level,
		Filepath: Filepath,
		Filename: Filename,
		maxSize:  10 * 1024 * 1024,
		lastTime: time.Now(),
	}
	FileObj.initFile()
	return FileObj
}

func (f *FileLogger) initFile() {
	logName := path.Join(f.Filepath, f.Filename)
	fileObj, err := os.OpenFile(logName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		panic(fmt.Errorf("打开日志文件%s异常, 报错:%v", logName, err))
	}
	f.file = fileObj
	errLogName := fmt.Sprintf("err_%s", logName)
	errFileObj, err := os.OpenFile(errLogName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		panic(fmt.Errorf("打开日志文件%s异常, 报错:%v", errLogName, err))
	}
	f.errFile = errFileObj
}

//再次封装写日志函数
func (f *FileLogger) wLog(logLevel string, format string, args ...interface{}) {
	if Getlevel(f.Level) > Getlevel(logLevel) {
		return
	}
	// 按大小拆分日志
	// f.file = f.checkSplitLog(f.file)
	f.checkSplitLog()
	msgInfo := fmt.Sprintf(format, args...)
	nowStr := time.Now().Format("2006-01-02 15:04:05.000")
	funcName, fileName, line := getCallerInfo(3)
	logMsg := fmt.Sprintf("[%s] [%s] [%s:%s] %d %s", nowStr, logLevel, fileName, funcName, line, msgInfo)
	_, _ = fmt.Fprintln(f.file, logMsg)
	if Getlevel(logLevel) >= Getlevel("ERROR") {
		// 按大小拆分时需要
		// f.errFile = f.checkSplitLog(f.errFile)
		_, _ = fmt.Fprintln(f.errFile, logMsg)
	}
}

//日志拆分
func (f *FileLogger) checkSplitLog() {
	// 按大小拆分
	// fileInfo, _ := file.Stat()
	// fileSize := fileInfo.Size()
	// if fileSize < f.maxSize {
	// 	return file
	// }
	// 按时间拆分
	timeD := time.Now().Sub(f.lastTime).Minutes()
	if timeD >= 1 {
		fileName := f.file.Name()
		backupName := fmt.Sprintf("%s_bak%v", fileName, time.Now().Unix())
		_ = f.file.Close()
		_ = os.Rename(fileName, backupName)
		fileObj, err := os.OpenFile(fileName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
		if err != nil {
			panic(fmt.Errorf("打开日志文件%s异常, 报错:%v", fileName, err))
		}

		errFileName := f.errFile.Name()
		errBackupName := fmt.Sprintf("%s_bak%v", errFileName, time.Now().Unix())
		_ = f.errFile.Close()
		_ = os.Rename(errFileName, errBackupName)
		errFileObj, err := os.OpenFile(errFileName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
		if err != nil {
			panic(fmt.Errorf("打开日志文件%s异常, 报错:%v", errFileName, err))
		}
		// 将当前时间复制给上次拆分时间
		f.lastTime = time.Now()
		f.file = fileObj
		f.errFile = errFileObj
	}
}

// Debug 调试日志
func (f *FileLogger) Debug(format string, args ...interface{}) {
	f.wLog("DEBUG", format, args...)
}

// Info 一般日志
func (f *FileLogger) Info(format string, args ...interface{}) {
	f.wLog("INFO", format, args...)
}

// Warn 警告日志
func (f *FileLogger) Warn(format string, args ...interface{}) {
	f.wLog("WARN", format, args...)
}

// Error 错误日志
func (f *FileLogger) Error(format string, args ...interface{}) {
	f.wLog("ERROR", format, args...)
}

// Fatal 严重错误日志
func (f *FileLogger) Fatal(format string, args ...interface{}) {
	f.wLog("FATAL", format, args...)
}

// Close 关闭文件句柄
func (f *FileLogger) Close() {
	_ = f.file.Close()
	_ = f.errFile.Close()
}

// utils.go
package logger

import (
	"path"
	"runtime"
)

func getCallerInfo(skip int) (funcName, fileName string, line int) {
	pc, fileName, line, ok := runtime.Caller(skip)
	if !ok {
		panic("获取程序信息失败")
	}
	funcName = path.Base(runtime.FuncForPC(pc).Name())
	fileName = path.Base(fileName)
	return
}

// console.go
package logger

import (
	"fmt"
	"os"
	"time"
)

// ConsoleLogger 终端结构体
type ConsoleLogger struct {
	Level string
}

// NewConsoleLogger 构造终端结构体函数
func NewConsoleLogger(Level string) *ConsoleLogger {
	ConsoleObj := &ConsoleLogger{
		Level: Level,
	}
	return ConsoleObj
}

//再次封装写日志函数
func (f *ConsoleLogger) wLog(logLevel string, format string, args ...interface{}) {
	if Getlevel(f.Level) > Getlevel(logLevel) {
		return
	}
	msgInfo := fmt.Sprintf(format, args...)
	nowStr := time.Now().Format("2006-01-02 15:04:05.000")
	funcName, fileName, line := getCallerInfo(3)
	logMsg := fmt.Sprintf("[%s] [%s] [%s:%s] %d %s", nowStr, logLevel, fileName, funcName, line, msgInfo)
	_, _ = fmt.Fprintln(os.Stdout, logMsg)
}

// Debug 调试日志
func (f *ConsoleLogger) Debug(format string, args ...interface{}) {
	f.wLog("DEBUG", format, args...)
}

// Info 一般日志
func (f *ConsoleLogger) Info(format string, args ...interface{}) {
	f.wLog("INFO", format, args...)
}

// Warn 警告日志
func (f *ConsoleLogger) Warn(format string, args ...interface{}) {
	f.wLog("WARN", format, args...)
}

// Error 错误日志
func (f *ConsoleLogger) Error(format string, args ...interface{}) {
	f.wLog("ERROR", format, args...)
}

// Fatal 严重错误日志
func (f *ConsoleLogger) Fatal(format string, args ...interface{}) {
	f.wLog("FATAL", format, args...)
}

// Close 终端不需要关闭
func (f *ConsoleLogger) Close() {

}

// 使用方法
package main

import (
	"time"

	logger "ropon.top/day04/1logger"
)

// blog测试项目

//定义全局变量log 接口
var log logger.Logger

func main() {
	//往文件中写日志
	//log = logger.NewFileLogger("Debug", "./", "blog.log")
	//往终端写日志
	log = logger.NewConsoleLogger("Info")
	defer log.Close()
	for i := 0; i < 10; i++ {
		x := 100
		log.Debug("这是一条Debug信息，调试程序而已")
		log.Info("这是一条Info信息，测试记录变量值%d", x)
		log.Error("这是一条Error信息，天啦程序奔溃")
		log.Fatal("这是一条Fatal信息，哇程序出错啦")
		time.Sleep(time.Second * 10)
	}
}