Go: What is the difference between log.Fatal and log.Panic?

log.Fatal — logs and exits (os.Exit(1)). log.Panic — logs and panics (panic()).

log.Fatal:

• Calls os.Exit(1) after logging.
• Deferred functions are NOT executed.
• No stack trace printed.
• Cannot be recovered.
• Program exits with code 1.

1func main() {
2    defer cleanup() // Will NOT run
3    
4    if err := startServer(); err != nil {
5        log.Fatal("Server failed: ", err)
6    }
7}

log.Panic:

• Calls panic() after logging.
• Deferred functions ARE executed.
• Stack trace is printed.
• Can be recovered with recover().
• Unrecovered panic crashes the program.

1func main() {
2    defer func() {
3        if r := recover(); r != nil {
4            log.Printf("Recovered: %v", r)
5        }
6    }()
7    
8    defer cleanup() // Will run
9    
10    if err := startServer(); err != nil {
11        log.Panic("Server failed: ", err)
12    }
13}

Variants:

• log.Fatalf(format, args...) — formatted Fatal.
• log.Panicf(format, args...) — formatted Panic.
• log.Fatalln(args...) — Fatal with newline.
• log.Panicln(args...) — Panic with newline.

When to use log.Fatal:

• Startup failures.
• Simple programs without cleanup.
• When immediate termination is needed.

When to use log.Panic:

• Errors requiring cleanup.
• Library code (caller can recover).
• Errors that should propagate.

Common mistakes:

• Using log.Fatal when cleanup is needed.
• Using log.Panic without recover().
• Forgetting log.Fatal skips deferred functions.
• Using either for normal error handling.
• Using log.Fatal in goroutines (exits entire process).