Go的日志库go-logging

配置文件config.yaml

log:
  prefix: '[MY-LOG] '
  log-file: true
  stdout: 'DEBUG'
  file: 'DEBUG'

config/config.go

package config

type Log struct {
        Prefix  string `mapstructure:"prefix" json:"prefix"`
        LogFile bool   `mapstructure:"log-file" json:"logFile"`
        Stdout  string `mapstructure:"stdout" json:"stdout"`
        File    string `mapstructure:"file" json:"file"`
}

type Config struct {
        Log Log `json:"log"`
}

global/global.go

package global

import (
        oplogging "github.com/op/go-logging"
        "github.com/spf13/viper"
        "go_Logger/config"
)

var (
        CONFIG config.Config
        VP     *viper.Viper
        LOG    *oplogging.Logger
)

读取配置文件

//const defaultConfigFile = "config/config.json"
const defaultConfigFile = "config/config.yaml"

func init() {
        v := viper.New()
        v.SetConfigFile(defaultConfigFile)
        err := v.ReadInConfig()
        if err != nil {
                panic(fmt.Errorf("Fatal error config file: %s \n", err))
        }
        v.WatchConfig()

        v.OnConfigChange(func(e fsnotify.Event) {
                fmt.Println("config file changed:", e.Name)
                if err := v.Unmarshal(&global.CONFIG); err != nil {
                        fmt.Println(err)
                }
        })
        if err := v.Unmarshal(&global.CONFIG); err != nil {
                fmt.Println(err)
        }
        global.VP = v
}

initizlize/go-logging.go

package initizlize

import (
        "fmt"
        rotatelogs "github.com/lestrrat/go-file-rotatelogs"
        oplogging "github.com/op/go-logging"
        "go_Logger/config"
        "go_Logger/global"
        "go_Logger/utils"
        "io"
        "os"
        "strings"
        "time"
)

const (
        logDir      = "log"
        logSoftLink = "latest_log"
        module      = "go_Logger"
)

var (
        defaultFormatter = `%{color}%{time:2006/01/02 - 15:04:05.000} %{longfile} %{color:bold}▶ [%{level:.6s}] %{message}%{color:reset}`
)

func InitGlobalLog() {
        c := global.CONFIG.Log
        if c.Prefix == "" {
                _ = fmt.Errorf("logger prefix not found")
        }
        logger := oplogging.MustGetLogger(module)
        var backends []oplogging.Backend
        backends = registerStdout(c, backends)
        backends = registerFile(c, backends)

        oplogging.SetBackend(backends...)
        global.LOG = logger
}

func registerStdout(c config.Log, backends []oplogging.Backend) []oplogging.Backend {
        if c.Stdout != "" {
                level, err := oplogging.LogLevel(c.Stdout)
                if err != nil {
                        fmt.Println(err)
                }
                backends = append(backends, createBackend(os.Stdout, c, level))
        }

        return backends
}

func registerFile(c config.Log, backends []oplogging.Backend) []oplogging.Backend {
        if c.File != "" {
                if ok, _ := utils.PathExists(logDir); !ok {
                        // directory not exist
                        fmt.Println("create log directory")
                        _ = os.Mkdir(logDir, os.ModePerm)
                }
                fileWriter, err := rotatelogs.New(
                        logDir+string(os.PathSeparator)+"%Y-%m-%d-%H-%M.log",
                        // generate soft link, point to latest log file
                        //rotatelogs.WithLinkName(logSoftLink),
                        // maximum time to save log files
                        rotatelogs.WithMaxAge(7*24*time.Hour),
                        // time period of log file switching
                        rotatelogs.WithRotationTime(24*time.Hour),
                )
                if err != nil {
                        fmt.Println(err)
                        return backends
                }
                level, err := oplogging.LogLevel(c.File)
                if err != nil {
                        fmt.Println(err)
                }
                backends = append(backends, createBackend(fileWriter, c, level))
        }

        return backends
}

func createBackend(w io.Writer, c config.Log, level oplogging.Level) oplogging.Backend {
        backend := oplogging.NewLogBackend(w, c.Prefix, 0)
        stdoutWriter := false
        if w == os.Stdout {
                stdoutWriter = true
        }
        format := getLogFormatter(c, stdoutWriter)
        backendLeveled := oplogging.AddModuleLevel(oplogging.NewBackendFormatter(backend, format))
        backendLeveled.SetLevel(level, module)
        return backendLeveled
}

func getLogFormatter(c config.Log, stdoutWriter bool) oplogging.Formatter {
        pattern := defaultFormatter
        if !stdoutWriter {
                // Color is only required for console output
                // Other writers don't need %{color} tag
                pattern = strings.Replace(pattern, "%{color:bold}", "", -1)
                pattern = strings.Replace(pattern, "%{color:reset}", "", -1)
        }
        if !c.LogFile {
                // Remove %{logfile} tag
                pattern = strings.Replace(pattern, "%{longfile}", "", -1)
        }
        return oplogging.MustStringFormatter(pattern)
}

　main.go

package main

import (
        "go_Logger/global"
        initizlize "go_Logger/initialize"
)

func main() {
        initizlize.InitGlobalLog()
        global.LOG.Debug("go-logging日志打印测试")
        global.LOG.Warning("go-logging日志打印测试")
        global.LOG.Error("go-logging日志打印测试")
}