问题背景

下列代码实现了使用 Logurs 日志框架输出日志时根据级别不同，使用对应的自定义颜色进行输出。那么思考下代码的逻辑是怎么实现的呢？

效果如下：

代码如下：

import (
	"fmt"
	"github.com/sirupsen/logrus"
	"github.com/fatih/color"
)

func main() {
	logger := logrus.New()
	logger.Formatter = &CustomTextFormatter{
		ForceColors:   true,
		ColorInfo:     color.New(color.FgBlue),
		ColorWarning:  color.New(color.FgYellow),
		ColorError:    color.New(color.FgRed),
		ColorCritical: color.New(color.BgRed, color.FgWhite),
	}

	logger.Info("This is an info message")   // 输出蓝色的信息日志
	logger.Warn("This is a warning message") // 输出黄色的警告日志
	logger.Error("This is an error message") // 输出红色的错误日志
	logger.Fatal("This is a critical message") // 输出带有红色背景和白色文本的严重日志

	logger.Panic("This is a critical message with panic") // 输出带有红色背景和白色文本的严重日志，并引发 panic
}

// 自定义格式化器，继承自 logrus.TextFormatter
type CustomTextFormatter struct {
	logrus.TextFormatter
	ForceColors   bool
	ColorInfo     *color.Color
	ColorWarning  *color.Color
	ColorError    *color.Color
	ColorCritical *color.Color
}

// 格式化方法，用于将日志条目格式化为字节数组
func (f *CustomTextFormatter) Format(entry *logrus.Entry) ([]byte, error) {
	if f.ForceColors {
		switch entry.Level {
		case logrus.InfoLevel:
			f.ColorInfo.Println(entry.Message) // 使用蓝色打印信息日志
		case logrus.WarnLevel:
			f.ColorWarning.Println(entry.Message) // 使用黄色打印警告日志
		case logrus.ErrorLevel:
			f.ColorError.Println(entry.Message) // 使用红色打印错误日志
		case logrus.FatalLevel, logrus.PanicLevel:
			f.ColorCritical.Println(entry.Message) // 使用带有红色背景和白色文本的样式打印严重日志
		default:
			f.PrintColored(entry)
		}
		return nil, nil
	} else {
		return f.TextFormatter.Format(entry)
	}
}

// 自定义方法，用于将日志条目以带颜色的方式打印出来
func (f *CustomTextFormatter) PrintColored(entry *logrus.Entry) {
	levelColor := color.New(color.FgCyan, color.Bold) // 定义蓝色和粗体样式
	levelText := levelColor.Sprintf("%-6s", entry.Level.String()) // 格式化日志级别文本

	msg := levelText + " " + entry.Message
	if entry.HasCaller() {
		msg += " (" + entry.Caller.File + ":" + strconv.Itoa(entry.Caller.Line) + ")"  // 添加调用者信息
	}

	fmt.Fprintln(color.Output, msg) // 使用有颜色的方式打印消息到终端
}

了解转义序列的颜色格式字符串

假如我们在代码中执行以下代码，那么你将会在控制台中看到带有红色的 “Hello World”：

str := fmt.Sprintf("\033[31m%s\033[0m", "Hello World")
fmt.Println(str)

这是因为我们使用 fmt.Sprintf 方法生成了一个带有转义序列的颜色格式字符串。

在这个格式字符串中，%s 是一个占位符，表示将要插入的字符串。而 \033[31m 和 \033[0m 是转义序列，用于在终端中设置文本的颜色，\033[31m 用于设置文本的颜色为红色，\033[0m 则是用于重置文本的颜色为默认值。

通过将实际的字符串插入到 %s 的位置，然后打印输出这个格式化字符串，可以在终端中实现相应部分带有颜色显示的效果。

**注：**该格式字符串的使用依赖于终端对 ANSI 转义序列的支持，因此可能在某些环境或终端下无效。

调用链

首先，我们的代码中定义了一个继承 logrus.TextFormatter 的结构体 CustomTextFormatter，并实现Format方法来自定义日志的输出格式。还将 Logrus 实例的 Formatter 设置为自定义格式化器 CustomTextFormatter：

logger := logrus.New()
logger.Formatter = &CustomTextFormatter{
    ForceColors:   true,
    ColorInfo:     color.New(color.FgBlue),
    ColorWarning:  color.New(color.FgYellow),
    ColorError:    color.New(color.FgRed),
    ColorCritical: color.New(color.BgRed, color.FgWhite),
}

logger.Info("This is an info message")
logger.Warn("This is a warning message")
logger.Error("This is an error message")
logger.Fatal("This is a critical message")

当调用 logger.Info() 时，会调用到 Logger.Log() 方法输出日志。Logger.Log() 首先通过调用 logger.IsLevelEnabled(level) 方法检查指定的日志级别是否启用。如果未启用，则直接返回，不执行后续的日志记录操作。

如果指定的日志级别是启用的，接下来会创建一个新的日志条目 entry，通过调用 logger.newEntry() 方法实现。

然后，通过调用 entry.Log(level, args...) 方法，将日志级别和参数传递给日志条目进行记录。这表示具体的日志记录操作和格式化输出由 entry.Log 方法负责执行。

最后，通过调用 logger.releaseEntry(entry) 方法释放和回收该日志条目的资源。

func (logger *Logger) Log(level Level, args ...interface{}) {
	if logger.IsLevelEnabled(level) {
		entry := logger.newEntry()
		entry.Log(level, args...)
		logger.releaseEntry(entry)
	}
}

在 entry.Log 中，首先使用 entry.Dup() 方法复制当前 Entry 实例的 Logger、Time、Context、err 创建一个新的 Entry 实例，并返回该新实例的指针，并将新实例的时间设置为当前时间，级别和消息设置为传入的参数值。这个新实例被称为 newEntry。

后续，通过调用 newEntry.write() 方法，将新实例 newEntry 的内容写入缓冲区 buffer 中。

最后，释放新实例 newEntry 的缓冲区，检查日志级别是否需要触发 panic，并在需要触发 panic 时抛出新实例 newEntry。

func (entry *Entry) log(level Level, msg string) {
	var buffer *bytes.Buffer

	newEntry := entry.Dup()

	if newEntry.Time.IsZero() {
		newEntry.Time = time.Now()
	}

	newEntry.Level = level
	newEntry.Message = msg

	newEntry.Logger.mu.Lock()
	reportCaller := newEntry.Logger.ReportCaller
	bufPool := newEntry.getBufferPool()
	newEntry.Logger.mu.Unlock()

	if reportCaller {
		newEntry.Caller = getCaller()
	}

	newEntry.fireHooks()
	buffer = bufPool.Get()
	defer func() {
		newEntry.Buffer = nil
		buffer.Reset()
		bufPool.Put(buffer)
	}()
	buffer.Reset()
	newEntry.Buffer = buffer

	newEntry.write()

	newEntry.Buffer = nil

	// To avoid Entry#log() returning a value that only would make sense for
	// panic() to use in Entry#Panic(), we avoid the allocation by checking
	// directly here.
	if level <= PanicLevel {
		panic(newEntry)
	}
}

newEntry.write() 方法就会调用 entry.Logger.Formatter.Format(entry) 方法将当前 Entry 实例格式化为字节流。注意，这里使用的 Formatter 是在创建 Logger 时指定的日志格式化器，也就是我们自定义的 CustomTextFormatter：

func (entry *Entry) write() {
	entry.Logger.mu.Lock()
	defer entry.Logger.mu.Unlock()
	serialized, err := entry.Logger.Formatter.Format(entry)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err)
		return
	}
	if _, err := entry.Logger.Out.Write(serialized); err != nil {
		fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
	}
}

而 CustomTextFormatter.Format() 方法我们已经实现了，根据日志级别选择设置对应的自定义颜色并打印日志消息。如果ForceColors为true，则使用定义的颜色样式来打印日志；否则，调用父类的TextFormatter.Format方法进行默认的格式化操作：

func (f *CustomTextFormatter) Format(entry *logrus.Entry) ([]byte, error) {
	if f.ForceColors {
		switch entry.Level {
		case logrus.InfoLevel:
			f.ColorInfo.Println(entry.Message)
		case logrus.WarnLevel:
			f.ColorWarning.Println(entry.Message)
		case logrus.ErrorLevel:
			f.ColorError.Println(entry.Message)
		case logrus.FatalLevel, logrus.PanicLevel:
			f.ColorCritical.Println(entry.Message)
		default:
			f.PrintColored(entry)
		}
		return nil, nil
	} else {
		return f.TextFormatter.Format(entry)
	}
}

当在调用 f.ColorInfo.Println() 中，会首先调用 c.Set() 方法，将当前颜色设置为控制台输出的颜色。接着使用 defer c.unset() 语句，确保在方法执行完毕后恢复控制台输出的默认颜色。这样可以避免影响后续输出的颜色。

最后，通过调用 fmt.Fprintln(Output, a...) 方法，格式化并输出参数 a... 的内容到指定的输出位置。

func (c *Color) Println(a ...interface{}) (n int, err error) {
	c.Set()
	defer c.unset()

	return fmt.Fprintln(Output, a...)
}

而到 Color 结构体的 Set 方法中会先通过调用 c.isNoColorSet() 方法检查是否设置了 noColor（不使用颜色）选项。如果设置了 noColor 选项，则直接返回 Color 结构体本身，不做任何操作。

如果未设置 noColor 选项，则调用 c.format() 方法生成带有转义序列的颜色格式字符串。然后使用 fmt.Fprint 方法将该颜色格式字符串输出到 Output（继承自 log 包）中。

// Set sets the SGR sequence.
func (c *Color) Set() *Color {
	if c.isNoColorSet() {
		return c
	}

	fmt.Fprint(Output, c.format())
	return c
}

Color 结构体的 format 方法会首先调用 c.sequence() 方法获取当前颜色序列的 ANSI 转义序列值。然后使用 fmt.Sprintf 方法将转义序列插入到格式化字符串中，生成完整的颜色格式字符串。

func (c *Color) format() string {
	return fmt.Sprintf("%s[%sm", escape, c.sequence())
}

其中，escape 是一个字符转义常量，表示 ANSI 转义序列的起始字符，通常为 \033。c.sequence() 方法返回的是字符串类型的 ANSI 转义序列，例如 "31" 表示红色文本。最后返回的是带有转义序列的颜色格式字符串，例如 \033[31m 表示设置文本颜色为红色。

最终调用链再执行到 fmt.Fprintln(Output, a...) 方法的 return fmt.Fprintln(Output, a...) 将格式化后的数据输出到指定的 io.Writer 接口上，并返回输出的字节数和可能的错误：

func Fprintln(w io.Writer, a ...any) (n int, err error) {
	p := newPrinter()
	p.doPrintln(a)
	n, err = w.Write(p.buf)
	p.free()
	return
}

---

整个原理就是这些！！！
感谢关注！！！