Zap logger in Go: SugaredLogger vs Logger, golang zap logging, request IDs

Readers search zap sugaredlogger, sugaredlogger, zap logger, golang zap, zap request id, zap logging, zap golang, zap sugaredlogger vs logger, golang zap logger, and zap logger golang for the same library: go.uber.org/zap, Uber’s structured zap logger for Go. This guide covers Logger vs SugaredLogger, correct Infow usage, zap request id patterns, levels with AtomicLevel, and production-style configuration—with links to the official docs for encoder tuning and rotation add-ons.

Examples assume a recent Go toolchain on Linux and zap v1.27+ in a Go module. Snippets use {run=false} because they import go.uber.org/zap outside the minimal Playground module set.

Install zap (golang zap, zap golang)

In a module:

text

go get go.uber.org/zap@latest

Import go.uber.org/zap. Commit go.sum changes in versioned services.

Zap sugaredlogger vs Logger (zap logger)

Typed Logger takes zap.Field values (zap.String, zap.Int, …). It is the default choice in hot paths where allocations matter.

SugaredLogger comes from logger.Sugar(). It adds Infof, Infow, and similar helpers. Zap sugaredlogger vs logger is mostly an ergonomics vs performance trade—benchmark your own message shape with Go benchmarks instead of relying on stale absolute timings from older posts.

go


package main

import (
	"go.uber.org/zap"
)

func main() {
	logger, err := zap.NewProduction()
	if err != nil {
		panic(err)
	}
	defer logger.Sync()

	logger.Info("typed", zap.String("request_id", "req-1"), zap.Int("status", 200))

	sugar := logger.Sugar()
	sugar.Infow("sugared", "request_id", "req-2", "path", "/api/health")
}

Run prints two JSON lines, each with request_id (and path on the sugared line). Avoid Infof when you want key-value structure; use Infow("msg", "key", value, ...) or the typed Info.

Zap request id and child loggers (zap request id)

For HTTP handlers, derive a per-request logger once, then pass it down (or store it on context with your own helper):

go


reqLog := logger.With(zap.String("request_id", requestID))
reqLog.Info("incoming", zap.String("method", "GET"))

With SugaredLogger:

go


s := logger.Sugar()
reqSugar := s.With("request_id", requestID)
reqSugar.Infow("incoming", "method", "GET")

That is the usual answer to zap request id: fields on a child logger so every line in the scope carries the same correlation id.

Levels and AtomicLevel (zap logging)

Zap levels map to zapcore.Level (Debug, Info, Warn, Error, …). zap.NewAtomicLevel() (or NewAtomicLevelAt) plugs into zap.Config.Level so you can call SetLevel while goroutines log—useful for temporary debug in production without restart.

go


package main

import (
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

func main() {
	al := zap.NewAtomicLevelAt(zapcore.InfoLevel)
	cfg := zap.NewProductionConfig()
	cfg.Level = al
	logger, err := cfg.Build()
	if err != nil {
		panic(err)
	}
	defer logger.Sync()

	logger.Info("info only before debug enabled")
	al.SetLevel(zapcore.DebugLevel)
	logger.Debug("now debug is visible")
}

Run shows the debug line only after SetLevel.

JSON, console, outputs, and rotation

zap.NewProduction() and zap.NewDevelopment() are opinionated starting points: production JSON to stdout, development console with different defaults. Customize zap.Config (Encoding, EncoderConfig, OutputPaths, ErrorOutputPaths) for files or dual writes. Log rotation is not built into zap itself—pair file OutputPaths with something like lumberjack from the ecosystem, or your platform’s log agent.

For contrasts with the standard library log package, see changing the default log format.

Summary

Zap logger and zap logging workflows center on zap.NewProduction / Config.Build, defer logger.Sync(), and choosing Logger (typed zap.Field) versus SugaredLogger for zap sugaredlogger-style ergonomics. Zap sugaredlogger vs logger boils down to typed fields vs Infow pairs; both support zap request id style correlation via With. Golang zap and zap golang are the same go.uber.org/zap module—pin versions, handle Build errors, and tune AtomicLevel when you need live level changes without redeploying.

References

Frequently Asked Questions

1. What is the difference between zap.Logger and zap.SugaredLogger?

Logger uses strongly typed zap.Field arguments for high performance; SugaredLogger adds Sugar() for looser APIs like Infow with alternating keys and values after the message.

2. How do I add a zap request id to every log line?

Create a child logger with logger.With(zap.String("request_id", id)) for typed logs, or sugar.With("request_id", id) for sugared logs, then log only through that child in the request scope.

3. Why does my SugaredLogger output show EXTRA or wrong fields?

Infof only accepts printf verbs; structured pairs belong in Infow after the template, or use the typed Logger with zap.String and related helpers.

4. How do I change log level at runtime in Zap?

Use zap.NewAtomicLevel or zap.AtomicLevel in Config.Level, then call atomicLevel.SetLevel in HTTP handlers or admin APIs without rebuilding the core.

5. Must I call Sync on zap.Logger?

Defer logger.Sync to flush buffered writers on exit; it is especially important when logging to files or stdout in short-lived programs.