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

log.Fatal — logs message and calls os.Exit(1) (program terminates, deferred functions skip). log.Panic — logs message and calls panic() (deferred functions execute, recover possible).

log.Fatal deep dive:

• Calls log.Output() then os.Exit(1).
• Deferred functions are NOT executed.
• No stack trace is printed.
• Process exits with code 1.
• Cannot be recovered.

1func main() {
2    defer cleanup() // Will NOT run
3    
4    cfg, err := loadConfig()
5    if err != nil {
6        log.Fatal("Failed to load config: ", err)
7    }
8    // ...
9}

log.Panic deep dive:

• Calls log.Output() then panic(msg).
• 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 criticalError {
11        log.Panic("Critical failure")
12    }
13}

Related functions:

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

When to use log.Fatal:

• Application startup failures (missing config, port in use).
• Simple programs without cleanup needs.
• When you want immediate termination.

When to use log.Panic:

• Errors requiring cleanup (deferred functions).
• Library code that might be recovered by caller.
• Errors that should propagate up the call stack.

Common mistakes:

• Using log.Fatal when cleanup is needed (use log.Panic instead).
• Using log.Panic without recover() somewhere.
• Forgetting log.Fatal skips deferred functions.
• Using either for normal error handling (return errors instead).
• Not checking if log.Fatal is called in goroutines (exits entire process).