Menjawab Tantangan Latensi Queue di Laravel

Untuk mengurangi latensi job queue Laravel, fokus pada penyediaan data referensi sebelum job dijalankan, menghindari cache miss berulang, serta memastikan tidak ada worker ganda memproses job yang sama. Pendekatan cache prefetch adaptif menyimpan data yang dibutuhkan job dalam cache dengan TTL yang disesuaikan, sementara locking terkoordinasi memastikan job dikeluarkan dari antrean hanya setelah bekerja siap.

Bagaimana Cache Prefetch Adaptif Bekerja

Ketika job baru masuk, worker harus menentukan data referensi apa yang diperlukan (misalnya user profile, pengaturan tenant, atau lookup ID). Daripada mengakses database setiap kali, worker pertama kali memeriksa cache dengan TTL yang dikonfigurasikan berdasarkan frekuensi akses. Jika data sudah ada (cache hit), job dapat berjalan tanpa menunggu I/O berat; jika tidak, worker mengisi cache dan menandai bahwa cache baru saja diisi sehingga worker lain tidak melakukan prefetch simultan.

Disebut adaptif karena TTL dan ukuran prefetch disesuaikan menurut pola akses: data yang sering digunakan diberi TTL pendek agar tetap segar, sedangkan data stabil mendapatkan TTL lebih panjang agar tidak sering diperbarui. TTL bisa disimpan di konfigurasi terpisah dengan struktur seperti:

'cache' => [
    'prefetch_ttl' => [
        'tenant_config' => 60, // detik, untuk config yang sering berubah
        'static_lookup' => 600 // data jarang berubah
    ],
    'prefetch_batch' => 50 // jumlah key yang diload sekaligus
]

Worker sebaiknya memeriksa TTL yang relevan sebelum mengambil job baru agar memahami masa cache berlaku.

Strategi Prefetch

Dalam job handler, tambahkan logika prefetch:

use Illuminate\Support\Facades\Cache;

$keys = ['tenant_config:'.$job->tenant_id, 'lookup:status'];
$missing = [];
foreach ($keys as $key) {
    if (!Cache::has($key)) {
        $missing[] = $key;
    }
}

if ($missing) {
    $data = $this->fetchFromDatabase($missing);
    foreach ($data as $key => $value) {
        Cache::put($key, $value, config(sprintf('cache.prefetch_ttl.%s', $key_type($key)), 300));
    }
}

Penggunaan `config()` memungkinkan TTL dinamis berdasarkan tipe data. Pastikan handler memfetch data dalam batch untuk menghindari N+1 query.

Locking Terkoordinasi

Untuk mencegah worker memroses job ganda akibat retry atau job queue yang tertunda, gunakan locking yang di-share. Pilihan populer:

  • Redis Distributed Lock: Gunakan `Cache::lock()` sebelum mengambil job. Lock ini bersifat cepat dan cocok saat worker banyak.
  • Database Advisory Lock: Berguna jika Redis tidak tersedia, lock terikat ke koneksi DB.

Contoh implementasi Redis:

$lock = Cache::lock('job:'.$job->id, 30);
if (!$lock->get()) {
    // worker lain sudah memproses job
    return;
}

try {
    // lakukan prefetch + proses job
} finally {
    $lock->release();
}

Impor strategi ini ke dalam job base class agar konsisten. Jika job memerlukan waktu lebih lama dari lock TTL, pastikan `block` di set atau worker memperpanjang lock secara berkala.

Pola Backoff dan Retry

Jika cache miss terjadi terus menerus, tambahkan backoff untuk menghindari spike akses database. Kombinasikan dengan locking sehingga worker yang gagal mengambil data tidak langsung melempar ulang job ke queue tanpa menunggu cache stabil.

Konfigurasi Worker dan Prefetch

Atur worker Laravel agar dapat mempertahankan prefetch adaptif:

  • Supervisor: Jalankan worker dengan `--sleep=3 --tries=3` dan `--timeout` sesuai rata-rata job.
  • Environment: Tetapkan variabel seperti `QUEUE_PREFETCH_ENABLED=true`, `QUEUE_CACHE_TTL_OVERRIDES` untuk environment staging vs production.
  • Batch Prefetch: Jangan prefetch terlalu banyak data per job, cukup data krusial. Terlalu besar akan menyebabkan cache churn.

Selain itu, pertimbangkan worker dengan `--memory=512` agar cache dan lock tidak dislingkar oleh GC.

Observabilitas untuk Latensi dan Throughput

Untuk memantau efektivitas strategi, pantau metrik berikut:

  • Queue latency: waktu rata-rata antara job diterbitkan dan mulai diproses.
  • Cache hit ratio: persentase prefetch yang langsung menyediakan data.
  • Worker throughput: job per menit. Jika turun saat cache miss naik, ada korelasi yang perlu ditelusuri.
  • Lock wait time: lama worker menunggu lock agar tidak terjadi deadlock.

Gunakan tooling seperti Laravel Telescope, Prometheus exporter, atau APM untuk melacak metrik ini. Tambahkan log saat cache miss dan saat worker menunggu lock sebagai trace untuk pembacaan nanti.

Pemetaan Alert

Siapkan alert ketika:

  • Cache hit ratio di bawah 70% dalam 10 menit terakhir.
  • Queue latency melewati threshold (misal 500ms) selama lebih dari 5 menit.
  • Lock wait time mendadak meningkat, menandakan kontensi.

Debugging dan Troubleshooting Umum

Jika backlog muncul setelah menerapkan cache atau lock, periksa hal-hal berikut:

  1. Cache TTL terlalu pendek: worker terus melakukan miss karena data dihapus sebelum dipakai.
  2. Prefetch terlalu besar: worker menunggu banyak payload sebelum memproses job sehingga pipeline melambat.
  3. Lock tidak dilepas: gunakan `finally` untuk selalu merilis lock. Gunakan timeout lock conservatively.
  4. Redis latency: saat Redis overload, lock dan cache menjadi bottleneck. Pantau latency Redis dan pertimbangkan redis cluster atau read replicas.

Gunakan command seperti php artisan queue:work --tries=3 --timeout=90 untuk replicasi dan debugging lokal. Sertakan `Log::debug()` pada path cache miss dan lock acquisition agar mudah dianalisis.

Kesimpulan

Cache prefetch adaptif, penguncian terkoordinasi, dan worker yang dikonfigurasi dengan baik secara kolektif memangkas latensi queue Laravel. Yang penting adalah memantau metrik utama, menyesuaikan TTL berdasarkan pola akses, serta memastikan locking tidak menciptakan bottleneck baru. Dengan observabilitas dan troubleshooting yang konsisten, Anda bisa menjaga throughput tinggi tanpa menambah beban database.