Exactly-once semantics (EOS) in Kafka - Time & Space Complexity

Time Complexity: Exactly-once semantics (EOS)

O(n)

Understanding Time Complexity

When using Kafka's exactly-once semantics (EOS), it is important to understand how the processing time changes as the number of messages grows.

We want to know how the cost of ensuring each message is processed exactly once scales with input size.

Scenario Under Consideration

Analyze the time complexity of the following Kafka producer code snippet using EOS.

Properties props = new Properties();
props.put("enable.idempotence", "true");
props.put("transactional.id", "txn-1");
producer.initTransactions();

for (int i = 0; i < n; i++) {
    producer.beginTransaction();
    producer.send(new ProducerRecord(topic, key, value));
    producer.commitTransaction();
}
    

This code sends n messages in separate transactions to guarantee exactly-once delivery.

Identify Repeating Operations

Look for repeated actions that affect time cost.

• Primary operation: Sending and committing a transaction for each message.
• How many times: Exactly n times, once per message.

How Execution Grows With Input

As the number of messages n increases, the number of transactions and sends also increases linearly.

Input Size (n)	Approx. Operations
10	10 sends and commits
100	100 sends and commits
1000	1000 sends and commits

Pattern observation: The work grows directly in proportion to the number of messages.

Final Time Complexity

Time Complexity: O(n)

This means the time to process messages with EOS grows linearly as you send more messages.

Common Mistake

[X] Wrong: "Exactly-once semantics means the processing time stays the same no matter how many messages are sent."

[OK] Correct: Each message requires a transaction commit, so more messages mean more work and longer total time.

Interview Connect

Understanding how exactly-once semantics affects processing time helps you explain trade-offs in real systems and shows you grasp important Kafka concepts.

Self-Check

What if we batch multiple messages in a single transaction? How would the time complexity change?