问题背景
下列代码实现了使用 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
}
整个原理就是这些！！！
感谢关注！！！