在使用零日志时，无法在运行时评估字段值。这是一个限制，因为无法动态显示字段值。为了解决这个问题，可以利用零日志的钩子机制。钩子是无状态函数，在每个事件调用，允许在将事件数据写入给定 io.writer 之前对其进行修改。通过实现一个自定义钩子，可以延迟评估字段值，并在事件写入时获取其最新值。

简介

零日志字段

我在我的 golang 项目中使用 github.com/rs/zerolog。

我知道我可以使用如下方式将字段添加到输出：

package main

import (
    "os"

    "github.com/rs/zerolog"
)

func main() {
    logger := zerolog.new(os.stderr).with().timestamp().logger()
    logger.int("myintfield", 42)
    logger.info("a regular log output") // this log entry will also contain the integer field `myintfield`
}

但是我想要的是在 logger.info("a常规日志输出") 行运行时评估字段 myintfield 的值是什么。

设置

我有一个带有 go-routines 的生产者/消费者设置（例如，参见 https://goplay.tools/snippet/hkomawqkcwj），并且我有两个整数，它们仍然以原子方式计算消费者和生产者 go-routines 的数量在业务。在拆除消费者和生产者后，我想在运行时显示这些数字。

这是使用 log 而不是 zerolog 时的代码：

package main

import (
    "fmt"
    "log"
    "os"
    "sync"
    "sync/atomic"
)

func main() {
    numproducers := int32(3)
    numconsumers := int32(3)

    producersrunning := numproducers
    consumersrunning := numconsumers

    var wg sync.waitgroup

    l := log.new(os.stderr, "", 0)

    // producers
    for i := int32(0); i < numproducers; i++ {
        idx := i
        wg.add(1)
        go (func() {
            // producer tear down
            defer func() {
                atomic.addint32(&producersrunning, -1)
                l.printf("producer-%3d . producersrunning: %3d\n", idx, producersrunning)
                wg.done()
            }()

            // this is where the actual producer works is happening
        })()
    }

    // consumers
    for i := int32(0); i < numconsumers; i++ {
        idx := i
        wg.add(1)
        go (func() {
            // consumer tear down
            defer func() {
                atomic.addint32(&consumersrunning, -1)
                l.printf("consumer-%3d . consumersrunning: %3d\n", idx, consumersrunning)
                wg.done()
            }()

            // this is where the actual consumer works is happening
        })()
    }

    fmt.println("waiting")
    wg.wait()
}

它输出类似这样的内容：

waiting
producer-  1 . producersrunning:   2
producer-  0 . producersrunning:   1
consumer-  1 . consumersrunning:   2
producer-  2 . producersrunning:   0
consumer-  2 . consumersrunning:   1
consumer-  0 . consumersrunning:   0

每个消费者/生产者一个记录器

使用 zerolog，您可以创建记录器并将它们传递给每个 go-routine：

logger := zerolog.new(os.stderr)

go myconsumer(logger.with().str("is", "consumer").logger())
go myproducer(logger.with().str("is", "producer").logger())

然后，您只需查看每个日志行中的 is 字段，就可以轻松地在日志中找出消息是来自消费者还是生产者。

但是如果我想始终在每个日志行中打印当前活跃的消费者/生产者的数量怎么办？您可能会想做这样的事情：

go myconsumer(logger.with().str("is", "consumer").int("consumersrunning", consumersrunning).logger())
go myproducer(logger.with().str("is", "producer").int("producersrunning", producersrunning).logger())

但是，当然，这只会打印创建 go 例程时 consumersrunning 和 producersrunning 的瞬时值。相反，我希望日志输出能够反映日志输出时的值。

摘要

我希望我的问题很清楚。我不确定这是否违反零的概念，但像这样的函数

func (e *event) deferredint(key string, i func()int) *event

如果它存在的话，可能会起作用。

还有其他方法可以达到同样的效果吗？

潜在的解决方法

我的意思是一种方法可能是用这样的函数调用替换 logger 变量：

logFunc := func() zerolog.Logger {
  return logger.With().Int("runningConcumers", runningConsumers).Logger()
}

然后可以使用 logfunc().msg("hello") 创建日志条目。这推迟了 runningconsumers 的评估，但也为每个日志条目创建了一个记录器，这感觉有点矫枉过正。

到目前为止，我希望我没有让你感到困惑。

正确答案

您可以添加 hook。针对每个日志记录事件都会评估 hook

https://go.dev/play/p/Q7doafJGaeE

package main

import (
    "os"

    "github.com/rs/zerolog"
)

type inthook struct {
    count int
}

func (h *inthook) run(e *zerolog.event, l zerolog.level, msg string) {
    e.int("count", h.count)
    h.count++
}

func main() {
    var inthook inthook
    log := zerolog.new(os.stdout).hook(&inthook)

    log.info().msg("hello world")
    log.info().msg("hello world one more time")
}

输出为

{"level":"info","count":0,"message":"hello world"}
{"level":"info","count":1,"message":"hello world one more time"}

需要指针来在调用 hook.run 之间保存 count

可能对您来说 HookFunc 更好。它是为每个事件调用的无状态函数。以下是为每条消息调用 prng 的函数挂钩示例：https://go.dev/play/p/xu6aXpUmE0v

package main

import (
    "math/rand"
    "os"

    "github.com/rs/zerolog"
)

func randomhook(e *zerolog.event, l zerolog.level, msg string) {
    e.int("random", rand.intn(100))
}

func main() {
    var randomhook zerolog.hookfunc = randomhook
    log := zerolog.new(os.stdout).hook(randomhook)

    log.info().msg("hello world")
    log.info().msg("hello world one more time")
}

输出

{"level":"info","random":81,"message":"hello world"}
{"level":"info","random":87,"message":"hello world one more time"}

您可以使用 zerolog Hook 来实现此目的。挂钩是带有 run 方法的接口，该方法在事件数据写入给定的 io.writer 之前调用（在您的情况下为 os.stderr）。

这里是一些示例代码：

type counter struct {
    name string
    value int32
}

func (c *counter) inc() { atomic.AddInt32(&c.value, 1) }
func (c *counter) dec() { atomic.AddInt32(&c.value, -1) }
func (c *counter) get() { atomic.LoadInt32(&c.value) }

func (c *counter) Run(e *zerolog.Event, _ zerolog.Level, _ string) {
    e.Int32(c.name, c.get())
}

int main() {
    numConsumers, numProducers := 3, 3

    consumersRunning := &counter{
        name: "consumersRunning",
        value: int32(numConsumers),
    }
    producersRunning := &counter{
        name: "producersRunning",
        value: int32(numProducers),
    }
    
    logger := zerolog.New(os.Stderr)
    consumerLogger := logger.With().Str("is", "consumer").Logger().Hook(consumersRunning)
    producerLogger := logger.With().Str("is", "producer").Logger().Hook(producersRunning)

    // your other code
}

您将使用计数器的 inc 和 dec 方法来修改正在运行的消费者/生产者的数量。

好了，本文到此结束，带大家了解了《在github.com/rs/zerolog的字段延迟评估》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！