Go log.Logger 输出到多路目标时如何保持格式一致

如果一条日志既要让容器采集，又要落到本地文件，最稳妥的做法是只创建一个 log.Logger：先把前缀、时间格式和换行规则固定下来，再用 io.MultiWriter 组合 os.Stdout 与文件句柄。这样格式化只发生一次，两个目标收到的内容自然一致。

先固定 Logger 的格式，再组合多个 Writer

log.New(out, prefix, flag) 的第一个参数是最终的 io.Writer，第二个参数是前缀，第三个参数控制日期、时间、微秒和文件位置等标记。关键点是先组合 Writer，再把组合结果交给 Logger；不要为标准输出和文件各写一套 Printf。

package main

import (
    "fmt"
    "io"
    "log"
    "os"
)

func newLogger() (*log.Logger, func() error, error) {
    // 追加模式保留旧日志；创建失败要在初始化阶段直接返回。
    file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
    if err != nil {
        return nil, nil, fmt.Errorf("open log file: %w", err)
    }

    // 一个 Logger 统一生成前缀和时间字段，MultiWriter 不再做格式化。
    targets := io.MultiWriter(os.Stdout, file)
    logger := log.New(targets, "app ", log.Ldate|log.Ltime|log.Lmicroseconds)

    // 把 Close 交给调用方，关闭错误不能被静默吞掉。
    closeFile := func() error { return file.Close() }
    return logger, closeFile, nil
}

func main() {
    logger, closeFile, err := newLogger()
    if err != nil {
        // 初始化错误还没有可靠的业务日志目标，先输出到标准错误。
        fmt.Fprintln(os.Stderr, err)
        return
    }
    defer func() {
        if err := closeFile(); err != nil {
            fmt.Fprintln(os.Stderr, "close log file:", err)
        }
    }()

    // Printf 生成的一整行会同时到达标准输出和 app.log。
    logger.Printf("worker=%s status=%s", "sync-1", "ready")
}

这里的格式协议只有一份：例如 app 2026/09/12 20:00:00.123456 worker=sync-1 status=ready 会被写成同一段字节。Ldate、Ltime、Lmicroseconds 的组合顺序由标准库定义，不要再在两个目标上手工拼接时间。

为什么 MultiWriter 能保持两份日志格式一致

Logger 的每次日志操作会对 Writer 发起一次 Write。当这个 Writer 是 io.MultiWriter(os.Stdout, file) 时，Logger 先完成前缀、标记和换行，再把这一整段数据交给 MultiWriter。MultiWriter 像 Unix 的 tee 一样，把同一份数据依次交给每个目标，因此它不会给文件加一套新前缀，也不会把标准输出重新格式化。

目标顺序也有实际含义：MultiWriter 会先写 os.Stdout，再写文件。如果标准输出写入失败，文件目标可能还没有被调用；反过来，如果文件写入失败，已经写到标准输出的内容不会自动撤回。它提供的是简单的多路写入，不是跨目标事务。

错误、并发与文件生命周期要分开处理

Printf、Println 这类便捷方法没有把写入错误返回给调用方。对“日志丢失就必须让当前操作失败”的场景，应改用 Logger.Output，因为它会返回 error。不过，即使检查了错误，也只能知道这次多路写入的结果，不能保证前面的目标没有留下部分内容。

func writeCritical(logger *log.Logger, detail string) error {
    // Output 会补齐换行并返回底层 Writer 的写入错误。
    if err := logger.Output(1, "critical: "+detail); err != nil {
        return fmt.Errorf("write critical log: %w", err)
    }
    return nil
}

// 多个 goroutine 可以共享同一个 Logger；不要让它们分别拼接同一行日志。
func report(logger *log.Logger, id string) {
    logger.Printf("request=%s done", id)
}

标准库文档保证 Logger 可被多个 goroutine 同时使用，并会串行化对 Writer 的访问。但这不等于文件轮转、跨进程追加或远程日志传输都自动安全：如果程序需要按大小切分文件、调用 Sync、压缩归档或发送结构化字段，应把这些职责交给专门的 Writer 或日志组件。

常见误区：不要为每个目标创建不同 Logger

下面这种写法看起来直观，却很容易让两份日志逐渐分叉：

// 两个 Logger 各自维护格式，后续修改很容易只改到其中一个。
stdoutLogger := log.New(os.Stdout, "app ", log.LstdFlags)
fileLogger := log.New(file, "file ", log.Ldate|log.Ltime)

// 两次调用还可能产生不同时间、不同前缀和不同换行内容。
stdoutLogger.Println("ready")
fileLogger.Println("ready")

除非你确实要给不同目标不同格式，否则应把差异放在 Writer 层，而不是复制 Logger 层。还要注意关闭顺序：文件只应由拥有它的代码调用一次 Close；若一个目标失效，MultiWriter 不会为已经成功的目标回滚，也不会替你重新尝试。

相关问题

io.MultiWriter 会并行写文件和标准输出吗？

不会。它按传入顺序逐个调用目标的 Write，并在遇到错误时停止后面的目标。需要异步、缓冲或失败重试时，要显式设计队列和错误策略。

只想把标准输出复制到文件，为什么不用两个 Printf？

两个 Printf 会让格式、时间和错误处理分成两份；使用一个 Logger 加 MultiWriter 更容易保持内容一致，也能让并发访问遵循同一把 Logger 锁。需要可靠落盘时，再补充文件同步或专业日志轮转方案。

参考：Go 官方 log 包文档与 io.MultiWriter 文档。本文代码展示的是结构与调用关系，图示为操作示意图和结果示意图，不代表在本机执行所得的截图。