At-Most-Once Delivery

// At-most-once — commit BEFORE processing (data loss if crash)
Properties props = new Properties();
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);

KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
consumer.subscribe(List.of("metrics"));

while (true) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(500));

    // COMMIT FIRST — at-most-once: crash after this but before processing = data loss
    consumer.commitSync();

    for (ConsumerRecord<String, String> record : records) {
        // If we crash here, records are already committed — will NOT be reprocessed
        processMetric(record.value());
    }
}

// enable.auto.commit=true produces the same at-most-once window:
// auto-commit fires after poll() but before processing completes

// at-most-once use case: metrics/telemetry (loss acceptable)
@KafkaListener(topics = "app-metrics", groupId = "metrics-aggregator")
public void onMetric(AppMetric metric) {
    // If this metric is lost due to consumer restart, it is acceptable
    // Missing one data point in a 1-minute aggregate is negligible
    metricsAggregator.record(metric.getName(), metric.getValue());
}

# application.yml — auto-commit for non-critical consumers
spring:
  kafka:
    consumer:
      enable-auto-commit: true
      auto-commit-interval: 1000  # commit every 1 second

// at-most-once NEVER appropriate for:
@KafkaListener(topics = "payments")
public void processPayment(Payment payment) {
    // A lost payment = unhappy customer + revenue loss
    // MUST use at-least-once with idempotent processing here
    chargeCard(payment);
}

// Delivery Semantics Comparison:
//
// ┌─────────────────┬──────────────────┬────────────────────────────────────────┐
// │ Semantic        │ Commit Timing    │ Risk                                   │
// ├─────────────────┼──────────────────┼────────────────────────────────────────┤
// │ At-most-once    │ Before process   │ Data loss on crash — no duplicates     │
// │ At-least-once   │ After process    │ Duplicates on crash — no data loss     │
// │ Exactly-once    │ Atomic with work │ Neither — requires transactions/EOS    │
// └─────────────────┴──────────────────┴────────────────────────────────────────┘
//
// In practice:
// At-most-once  → enable.auto.commit=true, or commitSync() before processing
// At-least-once → enable.auto.commit=false, commitSync/Async AFTER processing
// Exactly-once  → Kafka transactions (transactional.id + read_committed) or
//                 Kafka Streams (processing.guarantee=exactly_once_v2)
//
// Default behaviour of Spring @KafkaListener: at-least-once
// (auto-commit is disabled by Spring Kafka by default)