HTTP client — timeout, retry & pool

http.DefaultClient tidak punya timeout. Satu panggilan ke API yang menggantung akan menahan goroutine, koneksi, dan permintaan pengguna selamanya — dan itu cara paling umum kegagalan menyebar antar layanan.

Klien yang benar

// Dibuat SEKALI, di main, lalu dioper lewat konstruktor.
func NewKlien() *http.Client {
	tr := http.DefaultTransport.(*http.Transport).Clone()
	tr.MaxIdleConns = 100
	tr.MaxIdleConnsPerHost = 20         // default 2 — hampir selalu terlalu kecil
	tr.MaxConnsPerHost = 50
	tr.IdleConnTimeout = 90 * time.Second
	tr.ResponseHeaderTimeout = 5 * time.Second

	return &http.Client{
		Transport: tr,
		Timeout:   10 * time.Second,   // batas menyeluruh: DNS + koneksi + body
	}
}

Memakainya dengan benar

func (k *KlienPembayaran) Status(ctx context.Context, id string) (Status, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet,
		k.basis+"/pembayaran/"+url.PathEscape(id), nil)
	if err != nil {
		return Status{}, err
	}
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Authorization", "Bearer "+k.token)

	resp, err := k.http.Do(req)
	if err != nil {
		return Status{}, fmt.Errorf("panggil pembayaran: %w", err)
	}
	defer func() {
		// Baca sisa body SEBELUM menutup, supaya koneksinya bisa dipakai ulang.
		_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 1<<20))
		resp.Body.Close()
	}()

	if resp.StatusCode != http.StatusOK {
		return Status{}, fmt.Errorf("pembayaran balas %d", resp.StatusCode)
	}

	var s Status
	if err := json.NewDecoder(io.LimitReader(resp.Body, 1<<20)).Decode(&s); err != nil {
		return Status{}, fmt.Errorf("decode respons pembayaran: %w", err)
	}
	return s, nil
}

Retry: kapan boleh, kapan berbahaya

func (k *Klien) doRetry(req *http.Request, maks int) (*http.Response, error) {
	var errTerakhir error

	for percobaan := range maks {
		if percobaan > 0 {
			// Exponential backoff DENGAN jitter. Tanpa jitter, semua
			// container mencoba lagi pada milidetik yang sama — dan
			// justru itu yang menjatuhkan layanan yang baru pulih.
			jeda := time.Duration(1<<percobaan) * 100 * time.Millisecond
			jeda += time.Duration(rand.Int64N(int64(jeda / 2)))

			select {
			case <-time.After(jeda):
			case <-req.Context().Done():
				return nil, req.Context().Err()
			}
		}

		resp, err := k.http.Do(req)
		if err != nil {
			errTerakhir = err
			continue
		}
		if resp.StatusCode < 500 && resp.StatusCode != http.StatusTooManyRequests {
			return resp, nil
		}
		io.Copy(io.Discard, resp.Body)
		resp.Body.Close()
		errTerakhir = fmt.Errorf("status %d", resp.StatusCode)
	}
	return nil, errTerakhir
}

Circuit breaker: berhenti memanggil yang sudah pasti gagal

TERTUTUP  ──(kegagalan > ambang)──►  TERBUKA
   ▲                                    │
   │                              (setelah jeda)
   │                                    ▼
   └──(percobaan berhasil)──────  SETENGAH TERBUKA

Saat sebuah dependensi mati, memanggilnya terus hanya menahan goroutine dan koneksimu sendiri sampai timeout — dan permintaan penggunamu ikut lambat meski bagian lain aplikasi baik-baik saja. Circuit breaker membuat panggilan gagal seketika selama dependensi diketahui bermasalah, sehingga kamu bisa menyajikan versi terdegradasi (misalnya dari cache) alih-alih menunggu sia-sia.

Membuatnya bisa diuji

// Klien menerima *http.Client dari luar — tesnya tinggal mengoper
// klien yang menunjuk httptest.Server.
func TestStatus(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			w.Write([]byte(`{"status":"lunas"}`))
		}))
	defer srv.Close()

	k := NewKlienPembayaran(srv.URL, srv.Client())
	s, err := k.Status(context.Background(), "abc")
	...
}