C.A.R. Hoare merumuskan dua cara membangun perangkat lunak: membuat sistem sedemikian sederhana hingga jelas tidak ada kekurangannya, atau membuatnya sedemikian rumit hingga kekurangannya tidak tampak nyata. Dalam arsitektur pemrosesan latar belakang (worker queue), dikotomi ini terlihat jelas pada pertentangan antara Simple Correctness dan Complex Fault Tolerance.

Problem: Ilusi Pemrosesan Tepat Satu Kali (Exactly-Once)

Jaringan komputer tidak andal. Sistem antrean seperti RabbitMQ, AWS SQS, atau Kafka hanya menjamin pengiriman pesan minimal satu kali (at-least-once delivery). Ketika worker memproses pekerjaan (job) dan mengalami crash tepat sebelum mengirim sinyal acknowledgment (ACK), broker akan mengirim ulang pesan tersebut ke worker lain.

Pendekatan Complex Fault Tolerance merespons masalah ini dengan menumpuk mekanisme: distributed locks (misalnya Redlock), algoritma konsensus, state machine terdistribusi, dan automated dead-letter queue (DLQ) redrive. Sebaliknya, pendekatan Simple Correctness menerima realitas duplikasi pesan dan menyelesaikannya pada layer penyimpanan menggunakan primitif ACID yang sudah teruji: transaksi dan unique constraint.

Perbandingan Arsitektur dan Failure Modes

1. Complex Fault Tolerance: Redlock + Distributed State

Pendekatan ini biasanya mengandalkan koordinator eksternal (seperti Redis) untuk memastikan hanya satu worker yang mengeksekusi job pada satu waktu.

  • Bottleneck Koordinasi: Waktu tunggu lock terdistribusi menambah latensi round-trip (RTT) network sebelum pekerjaan inti dimulai.
  • Fencing Token Problem: Jika worker mengalami stop-the-world GC pause atau network stall yang melebihi batas TTL kunci, lock akan lepas dan diklaim worker lain. Saat worker pertama terbangun, split-brain write tetap terjadi jika sistem tidak mengimplementasikan fencing token secara ketat.
  • DLQ Poisoning: Redrive otomatis pada pesan yang gagal karena logic bug atau data rusak akan memicu cascading failure di seluruh pool worker.

2. Simple Correctness: Idempotent State Mutation

Pendekatan ini tidak mencegah worker lain mengeksekusi payload yang sama secara paralel. Pendekatan ini memastikan bahwa eksekusi kedua, ketiga, atau ke-N dari job yang sama menghasilkan state akhir yang identik atau gagal secara aman tanpa efek samping (side effects).

  • Single Source of Truth: Basis data relasional menangani konkurensi melalui isolation level dan index unique.
  • Bebas State Eksternal: Tidak memerlukan cluster Redis khusus untuk locking. Beban infrastruktur berkurang drastis.
  • Deterministic Failure: Pelanggaran constraint langsung terdeteksi oleh engine DB dan membatalkan transaksi seketika (atomic rollback).

Trade-off Operasional dan Konsistensi Data

ParameterSimple Correctness (DB Constraints)Complex Fault Tolerance (Distributed Locks)
InfrastrukturMinimal (Database saja)Tinggi (DB + Redis/ZooKeeper cluster)
KonsistensiKetat (ACID Guarantees)Eventual (Rentan clock drift & TTL expiry)
DebuggingMudah (Traceable via DB audit table)Sulit (Distributed race conditions)
Throughput CeilingDibatasi IOPS write DBDibatasi throughput lock manager & RTT

Implementasi Worker Idempoten Berbasis Database Constraint

Berikut implementasi runnable worker menggunakan Node.js dan SQLite murni (in-memory) tanpa dependensi eksternal. Sistem ini menjamin idempotensi pembayaran menggunakan UNIQUE constraint pada idempotency_key.

import sqlite3 from 'node:sqlite3';

const db = new sqlite3.Database(':memory:');

db.serialize(() => {
  db.run(`
    CREATE TABLE processed_jobs (
      idempotency_key TEXT PRIMARY KEY,
      result TEXT NOT NULL,
      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
    )
  `);
  db.run(`
    CREATE TABLE account_balances (
      account_id TEXT PRIMARY KEY,
      balance INTEGER NOT NULL
    )
  `);
  db.run(`INSERT INTO account_balances (account_id, balance) VALUES ('acc_123', 1000)`);
});

// ponytail: basic sqlite transaction, upgrade to postgres SELECT FOR UPDATE if distributed balances
function processPayment(job) {
  return new Promise((resolve, reject) => {
    db.serialize(() => {
      db.run('BEGIN IMMEDIATE', (err) => {
        if (err) return reject(err);

        // 1. Cek idempotensi via INSERT ke tabel kontrol
        const stmt = db.prepare('INSERT INTO processed_jobs (idempotency_key, result) VALUES (?, ?)');
        stmt.run(job.id, 'SUCCESS', function(insertErr) {
          if (insertErr) {
            // UNIQUE constraint violation: job sudah pernah diproses
            if (insertErr.message.includes('UNIQUE constraint failed')) {
              db.run('ROLLBACK', () => {
                resolve({ status: 'SKIPPED_DUPLICATE', jobId: job.id });
              });
              return;
            }
            db.run('ROLLBACK', () => reject(insertErr));
            return;
          }

          // 2. Eksekusi mutasi bisnis utama
          db.run(
            'UPDATE account_balances SET balance = balance - ? WHERE account_id = ?',
            [job.amount, job.accountId],
            function(updateErr) {
              if (updateErr) {
                db.run('ROLLBACK', () => reject(updateErr));
                return;
              }

              db.run('COMMIT', (commitErr) => {
                if (commitErr) return reject(commitErr);
                resolve({ status: 'PROCESSED', jobId: job.id });
              });
            }
          );
        });
        stmt.finalize();
      });
    });
  });
}

// Runnable check: Eksekusi job identik secara serial / replikasi at-least-once delivery
async function runVerification() {
  const job = { id: 'evt_pay_999', accountId: 'acc_123', amount: 200 };

  const firstRun = await processPayment(job);
  console.assert(firstRun.status === 'PROCESSED', 'First run must process');

  const duplicateRun = await processPayment(job);
  console.assert(duplicateRun.status === 'SKIPPED_DUPLICATE', 'Duplicate run must be skipped');

  db.get('SELECT balance FROM account_balances WHERE account_id = ?', ['acc_123'], (err, row) => {
    if (err) throw err;
    console.assert(row.balance === 800, `Expected balance 800, got ${row.balance}`);
    console.log('Verification passed: Idempotency preserved without distributed locks.');
  });
}

runVerification();

Dilewati: Distributed lock lease, state sync layer, outbox processor background daemon. Tambahkan layer tersebut hanya jika payload pekerjaan melibatkan integrasi HTTP pihak ketiga yang tidak dapat di-rollback dengan transaksi lokal.

Kapan Kompleksitas Diperlukan?

Pilih Simple Correctness saat seluruh state mutasi berada dalam boundary database yang sama atau dapat direpresentasikan sebagai append-only log. Pilih Complex Fault Tolerance hanya ketika:

  1. Operasi melibatkan mutasi external API non-idempoten tanpa dukungan idempotency-key HTTP header.
  2. Resource contention sangat tinggi hingga serialization failure pada database menghabiskan kapasitas CPU/pool koneksi.
  3. Proses memakan waktu komputasi intensif (misal: transcoding video puluhan menit) di mana menjalankan komputasi ulang menghabiskan bandwidth server secara signifikan.