Context — pembatalan & tenggat

Saat pengguna menutup browser, kueri database yang sedang berjalan untuk permintaan itu seharusnya ikut berhenti. Context adalah mekanisme yang membuat pembatalan itu menembus setiap lapisan.

Kenapa ada

// Tanpa context: kueri ini berjalan sampai selesai, meski penggunanya
// sudah menutup tab lima detik yang lalu.
rows, err := db.Query("SELECT ...")

// Dengan context: batal berarti batal, sampai ke driver database.
rows, err := db.QueryContext(ctx, "SELECT ...")

Satu permintaan HTTP di aplikasi nyata menyentuh belasan lapisan: handler → service → repository → driver database → soket. Context adalah satu-satunya cara sinyal "berhenti" menembus semuanya tanpa setiap lapisan menciptakan mekanismenya sendiri.

Empat cara membuatnya

ctx := context.Background()    // akar — di main() dan di tes
ctx := r.Context()             // di handler HTTP: sudah punya pembatalan klien

// Tenggat relatif
ctx, batal := context.WithTimeout(ctx, 3*time.Second)
defer batal()

// Tenggat absolut
ctx, batal := context.WithDeadline(ctx, waktuMulai.Add(30*time.Second))
defer batal()

// Pembatalan manual
ctx, batal := context.WithCancel(ctx)
defer batal()

// Pembatalan dengan alasan (Go 1.20+) — muncul di ctx.Err()
ctx, batal := context.WithCancelCause(ctx)
batal(fmt.Errorf("pengguna membatalkan"))

Membaca pembatalan

select {
case <-ctx.Done():
	return ctx.Err()          // DeadlineExceeded atau Canceled
case hasil := <-ch:
	return hasil, nil
}

// Di dalam loop panjang, periksa berkala
for i, item := range daftar {
	if i%100 == 0 {
		if err := ctx.Err(); err != nil {
			return err
		}
	}
	proses(item)
}

Anggaran waktu bertingkat

// Batas terluar dipasang sekali, di middleware.
func BatasWaktu(d time.Duration) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			ctx, batal := context.WithTimeout(r.Context(), d)
			defer batal()
			next.ServeHTTP(w, r.WithContext(ctx))
		})
	}
}

// Lapisan dalam mempersempit, tidak pernah memperlebar.
func (s *Layanan) Ambil(ctx context.Context, id int64) (Produk, error) {
	ctx, batal := context.WithTimeout(ctx, 2*time.Second)  // kueri DB
	defer batal()
	return s.db.Ambil(ctx, id)
}

WithTimeout selalu mengambil yang lebih ketat antara tenggat induk dan yang baru. Jadi lapisan dalam tidak bisa memperpanjang umur permintaan — hanya mempersempit. Ini yang membuat anggaran waktu bisa dijamin dari satu tempat.

WithValue: pakai hemat

// Kunci bertipe privat — mencegah tabrakan antar paket
type kunciCtx int

const (
	kunciRequestID kunciCtx = iota
	kunciPengguna
)

func DenganRequestID(ctx context.Context, id string) context.Context {
	return context.WithValue(ctx, kunciRequestID, id)
}

func RequestID(ctx context.Context) string {
	s, _ := ctx.Value(kunciRequestID).(string)
	return s
}

Context yang lepas dari permintaan

// Pekerjaan latar yang HARUS selesai meski respons sudah terkirim
ctx := context.WithoutCancel(r.Context())   // Go 1.21+: bawa nilainya, buang pembatalannya
ctx, batal := context.WithTimeout(ctx, 30*time.Second)

go func() {
	defer batal()
	defer pulihkan()
	simpanAudit(ctx, data)
}()

Sebelum Go 1.21, satu-satunya cara adalah memulai dari context.Background() — yang berarti request_id dan trace ikut hilang, sehingga pekerjaan latar jadi tidak bisa dilacak. Sekarang tidak perlu memilih.