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`
}

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

logger := zerolog.New(os.Stderr)
go myConsumer(logger.With().Str("is", "consumer").Logger())
go myProducer(logger.With().Str("is", "producer").Logger())

go myConsumer(logger.With().Str("is", "consumer").Int("consumersRunning", consumersRunning).Logger())
go myProducer(logger.With().Str("is", "producer").Int("producersRunning", producersRunning).Logger())

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

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

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

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

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
}