go-error-hygiene

Go Error Hygiene

Detect and fix the "handle errors more than once" antipattern across a Go codebase.

The Rule

An error should be handled exactly once. Handling means one of:

• Logging it (to stdout, a logger, or a tracing span)
• Returning it to the caller (wrapped with context)
• Degrading gracefully (fallback, retry, default value)

If you do more than one at the same call site, you're double-handling. The most common violation: log AND return.

Why It Matters

• Duplicate log lines obscure root cause during incidents
• Callers that receive the returned error may log it again, tripling noise
• Coupling observability (tracing/logging) with error propagation makes both harder to change
• Interior log noise buries the wrapped error chain that actually tells the story

Detection Procedure

Step 1: Find helper functions that log AND wrap

Search for functions that combine logging/tracing with error wrapping in a single call:

# Find definitions (handles both functions and methods)
rg -n "^func\b.*\b(Log|Trace|Record)\w*(Wrap|Error|Return)" --type go
rg -n "^func\b.*\b(Wrap|Return)\w*(Log|Trace|Record)" --type go

# Find usages of common helpers
rg -n "LogAndWrapError|logAndReturn|wrapAndLog|traceAndWrap" --type go

Read each definition. If the function both logs/traces AND returns a wrapped error, it's a codified antipattern.

Step 2: Find explicit log-then-return blocks

Search for logging calls near error returns:

# Standard library log (exclude Fatal -- it's terminal, not double-handling)
rg -n "log\.(Printf|Println|Print)\b" --type go -A 3

# Zap
rg -n "zap\.L\(\)\.(Error|Warn)|logger\.(Error|Warn|Errorw|Warnw)" --type go -A 3

# Slog
rg -n "slog\.(Error|Warn)" --type go -A 3

# OpenTracing/OpenTelemetry span logging
rg -n "span\.(LogFields|SetTag|RecordError|AddEvent)|tracing\.LogError" --type go -A 3

For each match, check whether a return ...err follows within 1-3 lines. If yes, it's a double-handle candidate.