github.com/rs/zerolog 字段的延期评估

Question

介绍

零日志字段

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

我知道我可以通过使用以下方式向 output 添加字段：

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 regular log output")行的运行时评估字段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，您可以创建记录器并将它们传递给每个执行例程：

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-routine 时打印consumersRunning和producersRunning的瞬时值。 相反，我希望日志 output 反映日志 output 时的值。

概括

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

func (e *Event) DeferredInt(key string, i func()int) *Event

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

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

潜在的解决方法

我的意思是一种方法是用 function 调用替换logger变量，如下所示：

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

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

到现在为止，我希望我没有让你感到困惑。

Answer 1

您可以添加一个钩子。 为每个日志记录事件评估挂钩

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")
}

Output 是

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

需要指针来保存对Hook.Run的调用之间的Count

可能对你HookFunc更好。 它是为每个事件调用的无状态 function。 这是为每条消息调用 PRNG 的 function 挂钩的示例： 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")
}

Output

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

Answer 2

您可以使用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方法来修改正在运行的消费者/生产者的数量。