go语言日志实现(打印日志、日志写入文件和日志切割)

log包定义了Logger类型，该类型提供了一些格式化输出的方法。本包也提供了一个预定义的“标准”logger，可以通过调用函数Print系列(Print|Printf|Println）、Fatal系列（Fatal|Fatalf|Fatalln）、和Panic系列（Panic|Panicf|Panicln）来使用，比自行创建一个logger对象更容易使用。

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

1.  
   能够拿到文件名函数名和行号
2.  
    
3.  
   可变参数的日志
4.  
   //......interface{}表示可变的任意参数，可不传也可传任意长度
5.  
   func (l Logger) Debug(msg string, a ...interface{}) {
6.  
   msg = fmt.Sprint(msg,a)
7.  
   if l.enable(DEBUG){
8.  
   now := time.Now()
9.  
   fmt.Printf("[%s] [Debug] %s",now.Format("2006-01-02 15:04:05"),msg);
10.  
    }
11.  
     
12.  
    }
13.  
    实现往文件里面写日志
14.  
    1.新建fileloger.go文件，用来提供写入日志的功能
15.  
     
16.  
    package log
17.  
     
18.  
    import (
19.  
    "errors"
20.  
    "fmt"
21.  
    "os"
22.  
    "path"
23.  
    "strings"
24.  
    "time"
25.  
    )
26.  
     
27.  
    type LogLevel uint16
28.  
    //日志级别
29.  
    const (
30.  
    UNKNOW LogLevel = iota
31.  
    DEBUG
32.  
    TRACE
33.  
    INFO
34.  
    WARNIG
35.  
    ERROR
36.  
    FATAL
37.  
     
38.  
    )
39.  
    //解析日志
40.  
    func paraLogLevel(s string) (LogLevel,error) {
41.  
    s = strings.ToLower(s)
42.  
    switch s {
43.  
     
44.  
    case "debug":
45.  
    return DEBUG,nil
46.  
     
47.  
    case "tarce":
48.  
    return TRACE,nil
49.  
    case "info":
50.  
    return INFO,nil
51.  
    case "warnig":
52.  
    return WARNIG,nil
53.  
    case "error":
54.  
    return ERROR,nil
55.  
    case "fatal":
56.  
    return FATAL,nil
57.  
    default:
58.  
    err:= errors.New("无效的日志级别")
59.  
    return UNKNOW,err
60.  
    }
61.  
    }
62.  
     
63.  
    //获取日志的字符串格式
64.  
    func getLogStr (level LogLevel) string {
65.  
     
66.  
    switch level {
67.  
     
68.  
    case DEBUG:
69.  
    return "debug"
70.  
     
71.  
    case TRACE:
72.  
    return "tarce"
73.  
    case INFO:
74.  
    return "info"
75.  
    case WARNIG:
76.  
    return "warnig"
77.  
    case ERROR:
78.  
    return "error"
79.  
    case FATAL:
80.  
    return "fatal"
81.  
    default:
82.  
    return "unknow"
83.  
    }
84.  
    }
85.  
     
86.  
    //定义日志的结构体
87.  
    type FileLogger struct{
88.  
    Level LogLevel
89.  
    filePath string
90.  
    fileName string
91.  
    //要打开和写入的文件，一个日志文件一个错误日志文件
92.  
    fileObj *os.File
93.  
    errfileObj *os.File
94.  
    maxFileSize int64
95.  
    }
96.  
     
97.  
    //构造函数
98.  
    func NewFlieLogger(LeveStr ,fp,fn string,size int64) *FileLogger{
99.  
     
100.  
     level, err := paraLogLevel(LeveStr)
101.  
     if err != nil {
102.  
     panic(err)
103.  
     }
104.  
     f1 := &FileLogger{
105.  
     Level: level,
106.  
     filePath: fp,
107.  
     fileName: fn,
108.  
     maxFileSize: size,
109.  
     }
110.  
     err= f1.initFile()
111.  
     if err != nil {
112.  
     panic(err)
113.  
     }
114.  
     return f1
115.  
     }
116.  
      
117.  
     //初始化要打开和写入的日志文件的操作
118.  
     func (f *FileLogger) initFile() (error) {
119.  
     join := path.Join(f.filePath, f.fileName)
120.  
     fileObj, err := os.OpenFile(join, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
121.  
     if err != nil {
122.  
     fmt.Printf("open log fail ,err: %v\n",err)
123.  
     return err
124.  
     }
125.  
      
126.  
     errFileObj, err := os.OpenFile(join ".err", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
127.  
     if err != nil {
128.  
     fmt.Printf("open log fail ,err: %v\n",err)
129.  
     return err
130.  
     }
131.  
     //日志文件都打开
132.  
     f.fileObj = fileObj;
133.  
     f.errfileObj = errFileObj;
134.  
     return nil
135.  
      
136.  
     }
137.  
     //判断级别
138.  
     func (l FileLogger) enable(logLevel LogLevel) bool {
139.  
     return l.Level >logLevel
140.  
     }
141.  
     //打印日志操作
142.  
     func (f *FileLogger) Log(leve LogLevel,msg string) {
143.  
     now := time.Now()
144.  
     if f.enable(leve){
145.  
      
146.  
     fmt.Fprintf(f.fileObj,"[%s] [%s] %s",now.Format("2006-01-02 15:04:05"),getLogStr(leve),msg);
147.  
     }
148.  
      
149.  
     if leve >ERROR{
150.  
      
151.  
     fmt.Fprintf(f.errfileObj,"[%s] [%s] %s",now.Format("2006-01-02 15:04:05"),getLogStr(leve),msg);
152.  
     }
153.  
     }
154.  
      
155.  
     func (l FileLogger) Debug(msg string, a ...interface{}) {
156.  
     msg = fmt.Sprint(msg,a)
157.  
     if l.enable(DEBUG){
158.  
     l.Log(DEBUG,msg)
159.  
     }
160.  
      
161.  
     }
162.  
      
163.  
     func (l FileLogger) Info(msg string, a ...interface{}) {
164.  
     msg = fmt.Sprint(msg,a)
165.  
     if l.enable(WARNIG){
166.  
     l.Log(WARNIG,msg)
167.  
     }
168.  
      
169.  
     }
170.  
      
171.  
      
172.  
     func (l FileLogger) Warning(msg string, a ...interface{}) {
173.  
     msg = fmt.Sprint(msg,a)
174.  
     if l.enable(WARNIG){
175.  
     l.Log(WARNIG,msg)
176.  
     }
177.  
      
178.  
     }
179.  
      
180.  
     func (l FileLogger) Error(msg string, a ...interface{}) {
181.  
     msg = fmt.Sprint(msg,a)
182.  
     if l.enable(ERROR){
183.  
     l.Log(ERROR,msg)
184.  
     }
185.  
      
186.  
     }
187.  
      
188.  
     func (l FileLogger) Fatal(msg string, a ...interface{}) {
189.  
     msg = fmt.Sprint(msg,a)
190.  
     if l.enable(FATAL){
191.  
     l.Log(FATAL,msg)
192.  
     }
193.  
      
194.  
     }
195.  
      
196.  
     func (f *FileLogger) Colse() {
197.  
     f.fileObj.Close()
198.  
     f.errfileObj.Close()
199.  
     }
200.  
     2.测试：
201.  
      
202.  
     func main() {
203.  
      
204.  
     newLog := log.NewFlieLogger("warnig","./","now.log",100*1024*1024)
205.  
     newLog.Debug("这是debug日志")
206.  
     newLog.Info("这是info日志")
207.  
     newLog.Warning("这是Warning日志")
208.  
     newLog.Error("这是ERROR日志")
209.  
     newLog.Fatal("这是FATAL日志")
210.  
     newLog.Colse()
211.  
      
212.  
     }
213.  
     //运行两次后，打印结果：

日志切割（按文件大小切割、按日期切割）

其实就是每次记录文件的大小，超过了就重新写一个文件。

通过Stat()函数拿到文件的一些信息

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

日期切割：

拿到文件的名称或者检查下有没有当天的日志文件，没有就创建新增。

这篇好文章是转载于：学新通技术网