24 — Time & Dates

func startCleanup(ctx context.Context, interval time.Duration) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            if err := cleanupExpiredSessions(ctx); err != nil {
                log.Printf("cleanup error: %v", err)
                // continue running — don't stop on error
            }
        case <-ctx.Done():
            log.Println("cleanup goroutine shutting down")
            return  // graceful exit on cancellation
        }
    }
}

func main() {
    ctx, cancel := signal.NotifyContext(context.Background(),
        syscall.SIGINT, syscall.SIGTERM)
    defer cancel()

    go startCleanup(ctx, 5*time.Minute)

    // ... main server loop ...
    <-ctx.Done()
}

💡 Tips & Tricks

• Idiom: use t.Equal(t2) to compare times, not == — Equal compares the instant, ignoring location and monotonic differences. == compares all three and gives false for the same instant in different timezones.
• Idiom: use AddDate for calendar arithmetic (months, years) — t.AddDate(0, 1, 0) adds a calendar month (handles Feb 28/29). t.Add(30 * 24 * time.Hour) is NOT a month — months have different day counts.
• Idiom: use IANA timezone names ("America/New_York"), not abbreviations ("EST") — abbreviations have no DST rules. time.LoadLocation("America/New_York") handles DST automatically.
• Idiom: use time.Now().Sub(t) (monotonic clock) for measuring elapsed time — it's unaffected by NTP adjustments or DST changes. Parsed times have no monotonic clock.
• Idiom: always defer ticker.Stop() / defer timer.Stop() — without Stop, the timer goroutine lingers (resource leak). In tight loops, use time.NewTimer + Stop instead of time.After (which leaks).
• Portability: import _ "time/tzdata" to embed the timezone database — needed on systems without /usr/share/zoneinfo (some minimal Docker images, Windows). Adds ~450KB to the binary.

⚠️ Edge Cases & Gotchas

• == vs Equal: == compares wall + monotonic + location; Equal compares only the instant. Use Equal for "same moment."
• Parsed times have no monotonic clock: time.Parse returns a time with only the wall clock. Sub uses the wall clock (less reliable for elapsed time).
• AddDate normalizes: time.Date(2024, 1, 31, 0, 0, 0, 0, UTC).AddDate(0, 1, 0) → Feb 29 (2024 is a leap year). Adding a month to the 31st normalizes to the last day of the target month.
• time.Sleep can't be cancelled: time.Sleep(d) blocks the goroutine for d, ignoring context. Use time.NewTimer + select with ctx.Done() for cancellable waits.
• time.After leaks: the timer goroutine lives until the duration elapses, even if the select took another case. In hot loops, use time.NewTimer + Stop.
• time.LoadLocation can fail: on systems without the tz database, it returns an error. Import _ "time/tzdata" to embed the database.
• DST changes: adding 24 * time.Hour across a DST boundary gives 23 or 25 hours of wall-clock time (but 24 hours of monotonic time). Use AddDate(0, 0, 1) for "next day at the same wall-clock time."
• time.Now() is monotonic: time.Now() includes the monotonic clock. Subtracting two Now() values gives accurate elapsed time regardless of NTP.
• Timezone abbreviations are ambiguous: "CST" can be Central Standard Time (US), China Standard Time, or Cuba Standard Time. Always use IANA names.

🧠 Quick Quiz

t1, _ := time.Parse(time.RFC3339, "2024-03-15T14:30:00Z")
t2, _ := time.Parse(time.RFC3339, "2024-03-15T14:30:00Z")

fmt.Println(t1 == t2)
fmt.Println(t1.Equal(t2))