log:

  prefix: '[MY-LOG] '

  log-file: true

  stdout: 'DEBUG'

  file: 'DEBUG'

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"`

}

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

}

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)

}

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日志打印测试")

}