结构化日志记录logrus

package logs

import "io"

type LogWriter interface {
	Flush() // 刷盘
	io.Writer
}

var writerAdapter = make(map[string]func() LogWriter, 0) // 这里是直接一个适配器预先分配一个Log对象还是一个初始化方法？自然是方法，节省内存

func RegisterInitWriterFunc(adapterName string, writerFunc func() LogWriter) {
	writerAdapter[adapterName] = writerFunc
}

package logs

import "os"

type stdWriter struct {
	*os.File
}

func (s *stdWriter) Flush() {
	s.Sync()
}

func newStdWriter() LogWriter {
	return &stdWriter{
		os.Stderr,
	}
}

func init() {
	RegisterInitWriterFunc("std", newStdWriter)
}

package logs

import "os"

const LOGPATH = "runtime/logs/mylogs.log"

type fileWriter struct {
	*os.File
}

func (s *fileWriter) Flush() {
	s.Sync()
}

func newFileWriter() LogWriter {
	file, err := os.OpenFile(LOGPATH, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		file = os.Stderr
	}
	return &fileWriter{
		file,
	}
}

func init() {
	RegisterInitWriterFunc("file", newFileWriter)
}

package logs

import (
	"log"
	"time"

	rotatelogs "github.com/lestrrat-go/file-rotatelogs"
)

type fileRotateWriter struct {
	*rotatelogs.RotateLogs
}

func (fr *fileRotateWriter) Flush() {
	fr.Close()
}

func newFileRotateWriter() LogWriter {
	writer, err := getRotateLogs()
	if err != nil {
		log.Fatal(err)
	}
	return &fileRotateWriter{
		writer,
	}
}

func getRotateLogs() (*rotatelogs.RotateLogs, error) {
	path := LOGPATH
	logf, err := rotatelogs.New(
		path+".%Y%m%d%H%M",                      // 名字格式
		rotatelogs.WithLinkName(path),           // 将最新文件软链到path，windows环境不支持
		rotatelogs.WithMaxAge(time.Second*1800), // 日志最长保存时长
		rotatelogs.WithRotationTime(time.Hour),  // 日志多久保存
	)
	return logf, err
}

func init() {
	RegisterInitWriterFunc("file-rotate", newFileRotateWriter)
}

package logs

import (
	"log"

	"github.com/sirupsen/logrus"
)

type MyHook struct{}

func (hook *MyHook) Levels() []logrus.Level {
	// return logrus.AllLevels
	return []logrus.Level{logrus.ErrorLevel}
}

func (hook *MyHook) Fire(entry *logrus.Entry) error {
	log.Printf("%+v", entry)
	return nil
}

package logs

import (
	"github.com/sirupsen/logrus"
)

type Log struct {
	*logrus.Entry // 直接内嵌
	LogWriter
}

func (l *Log) Flush() {
	l.LogWriter.Flush()
}

type LogConf struct {
	Level       logrus.Level
	AdapterName string
	Hook        logrus.Hook
}

func InitLog(conf LogConf) *Log {
	adapterName := "std"
	if conf.AdapterName != "" {
		adapterName = conf.AdapterName
	}
	writerFunc, ok := writerAdapter[adapterName]
	if !ok {
		adapterName = "std"
		writerFunc, _ = writerAdapter[adapterName]
	}
	log := &Log{
		logrus.NewEntry(logrus.New()),
		writerFunc(),
	}
	log.Logger.SetFormatter(&logrus.JSONFormatter{}) // 格式
	if conf.Hook != nil {
		log.Logger.AddHook(conf.Hook)
	}
	log.Logger.SetOutput(log.LogWriter) // 输出位置，默认就是控制台
	if conf.Level != 0 {
		log.Logger.SetLevel(conf.Level) // 等级
	}
	log.Logger.SetReportCaller(true) // 报告所在的行号
	return log
}

package main

import (
	"logrus/logs"

	"github.com/sirupsen/logrus"
)

func main() {
	conf := logs.LogConf{
		Level:       logrus.InfoLevel,
		AdapterName: "file-rotate",
		Hook:        &logs.MyHook{},
	}
	log := logs.InitLog(conf)

	log.WithFields(logrus.Fields{
		"animal": "walrus",
		"size":   10,
	}).Info("A group of walrus emerges from the ocean") // 因为级别是warn，info不会打印

	log.WithFields(logrus.Fields{
		"omg":    true,
		"number": 122,
	}).Error("The group's number increased tremendously!")

	log.WithFields(logrus.Fields{
		"omg":    true,
		"number": 100,
	}).Warn("the ice breaks!") // fatal和log的fatal一样，打印完就退出程序

	contextLogger := log.WithFields(logrus.Fields{
		"common": "this is a common field",
		"other":  "i also should be logged always",
	})

	contextLogger.Info("i'll be logged with common and other field")
	contextLogger.Info("me too")
	defer log.Flush()
}