Error Handling — Find the Bug¶

func loadConfig(path string) (Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return Config{}, fmt.Errorf("read config %q: %w", path, err)
    }
    var cfg Config
    if err := json.Unmarshal(data, &cfg); err != nil {
        return Config{}, fmt.Errorf("parse config %q: %w", path, err)
    }
    if cfg.MaxConnections == 0 {
        cfg.MaxConnections = 100 // a default is fine once we KNOW the file parsed
    }
    return cfg, nil
}

// caller:
cfg, err := loadConfig(path)
if err != nil {
    log.Fatalf("config: %v", err)   // fail loud, fail at boot
}

func writeReport(path string, rows []Row) (err error) {
    f, err := os.Create(path)
    if err != nil {
        return err
    }
    defer func() {
        if cerr := f.Close(); cerr != nil && err == nil {
            err = fmt.Errorf("close %q: %w", path, cerr)
        }
    }()

    w := bufio.NewWriter(f)
    for _, r := range rows {
        if _, err = fmt.Fprintf(w, "%s,%d\n", r.Name, r.Value); err != nil {
            return err
        }
    }
    if err = w.Flush(); err != nil {       // surface the buffered-write failure
        return fmt.Errorf("flush %q: %w", path, err)
    }
    return nil
}

func fetchUser(id string) (*User, error) {
    u, err := db.QueryUser(id)
    if err != nil {
        return nil, fmt.Errorf("fetchUser %s: %w", id, err)  // %w, not %v
    }
    return u, nil
}

func fetchWithRetry(ctx context.Context, url string) ([]byte, error) {
    const maxAttempts = 5
    var lastErr error
    for attempt := 0; attempt < maxAttempts; attempt++ {
        body, retryable, err := tryFetch(ctx, url)
        if err == nil {
            return body, nil
        }
        lastErr = err
        if !retryable {
            return nil, err             // 4xx etc. — fail fast, don't hammer
        }
        backoff := time.Duration(1<<attempt) * 100 * time.Millisecond
        jitter := time.Duration(rand.Int63n(int64(backoff)))
        select {
        case <-time.After(backoff + jitter):
        case <-ctx.Done():
            return nil, ctx.Err()
        }
    }
    return nil, fmt.Errorf("exhausted retries: %w", lastErr)
}

func tryFetch(ctx context.Context, url string) (body []byte, retryable bool, err error) {
    req, _ := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, true, err                       // network error: retryable
    }
    defer resp.Body.Close()                          // runs at end of THIS call
    switch {
    case resp.StatusCode == http.StatusOK:
        b, err := io.ReadAll(resp.Body)
        return b, false, err
    case resp.StatusCode >= 500 || resp.StatusCode == http.StatusTooManyRequests:
        return nil, true, fmt.Errorf("status %d", resp.StatusCode)   // retryable
    default:
        return nil, false, fmt.Errorf("status %d", resp.StatusCode)  // 4xx: terminal
    }
}

func parseAmount(s string) (int64, error) {
    cents, err := strconv.ParseInt(s, 10, 64)
    if err != nil {                                       // check error FIRST
        return 0, fmt.Errorf("invalid amount %q: %w", s, err)
    }
    if cents < 0 {                                        // value is trustworthy now
        return 0, fmt.Errorf("amount cannot be negative: %s", s)
    }
    return cents, nil
}