问题背景

下列代码实现了使用 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.TextFormatterForceColors   boolColorInfo     *color.ColorColorWarning  *color.ColorColorError    *color.ColorColorCritical *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.Messageif 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.BuffernewEntry := entry.Dup()if newEntry.Time.IsZero() {newEntry.Time = time.Now()}newEntry.Level = levelnewEntry.Message = msgnewEntry.Logger.mu.Lock()reportCaller := newEntry.Logger.ReportCallerbufPool := newEntry.getBufferPool()newEntry.Logger.mu.Unlock()if reportCaller {newEntry.Caller = getCaller()}newEntry.fireHooks()buffer = bufPool.Get()defer func() {newEntry.Buffer = nilbuffer.Reset()bufPool.Put(buffer)}()buffer.Reset()newEntry.Buffer = buffernewEntry.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
}

---

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