Memory and buffer configuration in Kafka - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of the producer buffer size setting?

Consider a Kafka producer configured with buffer.memory=33554432 (32 MB). What is the maximum amount of memory the producer can use to buffer records waiting to be sent?

Kafka

Properties props = new Properties();
props.put("buffer.memory", "33554432");
KafkaProducer<String, String> producer = new KafkaProducer<>(props);
System.out.println(producer.metrics().get("bufferpool-total-bytes").metricValue());

A 0

B 33554432

C 67108864

D 1048576

💡 Hint

The buffer.memory property sets the total bytes of memory the producer can use to buffer records.

The buffer.memory setting controls the total bytes of memory the producer can use to buffer records before sending. Setting it to 33554432 means 32 MB of buffer memory.

❓ Predict Output

intermediate

What happens if fetch.min.bytes is set too high?

In a Kafka consumer configuration, if fetch.min.bytes is set to 1048576 (1 MB), what is the expected behavior when the broker has less data available?

Kafka

Properties props = new Properties();
props.put("fetch.min.bytes", "1048576");
KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
System.out.println(records.count());

A Consumer waits until 1 MB of data is available before returning any records.

B Consumer returns zero records and closes the connection.

C Consumer throws an exception if less than 1 MB is available.

D Consumer immediately returns any available data regardless of size.

💡 Hint

fetch.min.bytes controls the minimum amount of data the broker returns to the consumer.

Setting fetch.min.bytes to 1 MB means the consumer will wait until at least 1 MB of data is available before returning records, which can increase latency but improve throughput.

🔧 Debug

advanced

Why does the producer throw a BufferExhaustedException?

A Kafka producer configured with buffer.memory=16384 (16 KB) and batch.size=32768 (32 KB) throws a BufferExhaustedException during high load. Why?

Kafka

Properties props = new Properties();
props.put("buffer.memory", "16384");
props.put("batch.size", "32768");
KafkaProducer<String, String> producer = new KafkaProducer<>(props);
// High volume sending loop
for (int i = 0; i < 100000; i++) {
    producer.send(new ProducerRecord<>("topic", "key", "value"));
}

A The producer is missing the linger.ms setting, causing immediate sends.

B batch.size is smaller than buffer.memory, causing buffer overflow.

C buffer.memory is smaller than batch.size, so the producer cannot allocate enough buffer for a batch.

D The producer's max.request.size is too large.

💡 Hint

buffer.memory must be at least as large as batch.size to hold a batch in memory.

The producer's buffer.memory is 16 KB but batch.size is 32 KB, so the producer cannot allocate enough memory for a batch, causing BufferExhaustedException.

📝 Syntax

advanced

Identify the syntax error in this Kafka consumer buffer configuration

Which option contains a syntax error in setting the consumer's fetch.max.bytes property in Java?

Kafka

Properties props = new Properties();

A ;)"00882425" ,"setyb.xam.hctef"(tup.sporp

B props.put("fetch.max.bytes", 52428800);

C props.put("fetch.max.bytes", "52428800");

D props.put(fetch.max.bytes, "52428800");

💡 Hint

Property keys must be strings in quotes.

Option D misses quotes around the property key, causing a compile-time error because fetch.max.bytes is not defined as a variable.

🚀 Application

expert

Calculate total memory usage for a Kafka producer with multiple buffers

A Kafka producer is configured with buffer.memory=67108864 (64 MB), batch.size=16384 (16 KB), and max.in.flight.requests.per.connection=5. What is the minimum total memory the producer needs to handle 5 in-flight batches without blocking?

A 81920 bytes plus overhead, but less than 67108864 bytes

B 67108864 bytes

C 81920 bytes

D More than 67108864 bytes

💡 Hint

Total memory must cover all in-flight batches but cannot exceed buffer.memory.

Each batch is 16384 bytes. For 5 in-flight requests, minimum memory is 5 * 16384 = 81920 bytes. This is less than buffer.memory (64 MB), so the producer can handle it without blocking. Actual usage includes overhead, so total is slightly more than 81920 bytes but less than 67108864 bytes.

Practice

1. Which Kafka configuration setting controls the size of the buffer used to batch data before sending to brokers?

easy

A. fetch.min.bytes

B. batch.size

C. buffer.memory

D. linger.ms

Solution

1. Step 1: Understand buffer settings in Kafka producer

   The batch.size setting controls the maximum size of a batch of records sent to brokers.

2. Step 2: Differentiate from other buffer-related settings

   buffer.memory controls total memory for buffering, fetch.min.bytes is for consumers, and linger.ms controls delay before sending batches.

3. Final Answer:

   batch.size -> Option B

4. Quick Check:

   Batch size controls batch buffer size [OK]

Hint: Batch size sets buffer for sending data batches [OK]

Common Mistakes:

• Confusing total buffer memory with batch size
• Mixing consumer fetch settings with producer buffers
• Thinking linger.ms controls buffer size

2. Which of the following is the correct syntax to set the buffer memory size to 32MB in Kafka producer properties file?

easy

A. buffer.memory=33554432

B. buffer.memory=32

C. buffer.memory=32m

D. buffer.memory=32MB

Solution

1. Step 1: Understand Kafka config value units

   Kafka expects buffer.memory in bytes, not with units like MB or m.

2. Step 2: Convert 32MB to bytes

   32MB = 32 * 1024 * 1024 = 33554432 bytes, so the value must be numeric bytes.

3. Final Answer:

   buffer.memory=33554432 -> Option A

4. Quick Check:

   Buffer memory uses bytes, not MB string [OK]

Hint: Use bytes number, not MB string, for buffer.memory [OK]

Common Mistakes:

• Adding MB or m suffix which Kafka does not parse
• Using too small number without units
• Confusing buffer.memory with batch.size units

3. Given this Kafka producer config snippet:

buffer.memory=1048576
batch.size=16384
linger.ms=10

What is the maximum amount of data (in bytes) that can be buffered before sending?

medium

A. 1048586 bytes

B. 16384 bytes

C. 1048576 bytes

D. 10 bytes

Solution

1. Step 1: Identify buffer.memory meaning

   buffer.memory is the total bytes available to buffer records waiting to be sent.

2. Step 2: Understand batch.size role

   batch.size is max size per batch, but total buffer can hold multiple batches up to buffer.memory.

3. Final Answer:

   1048576 bytes -> Option C

4. Quick Check:

   Total buffer memory = 1048576 bytes [OK]

Hint: buffer.memory is total buffer size, batch.size is per batch [OK]

Common Mistakes:

• Confusing batch.size as total buffer
• Adding linger.ms value to buffer size
• Choosing sum of batch.size and buffer.memory

4. You set buffer.memory=1024 and batch.size=2048 in Kafka producer config. What issue will occur?

medium

A. Producer will throw a configuration error on startup

B. No issue; Kafka adjusts batch.size automatically

C. Producer will silently drop messages exceeding buffer.memory

D. Producer will block or throw an error when batch.size exceeds buffer.memory

Solution

1. Step 1: Compare batch.size and buffer.memory values

   Here, batch.size (2048) is larger than buffer.memory (1024), which is invalid.

2. Step 2: Kafka behavior on invalid buffer sizes

   Kafka producer will block or throw an error because it cannot allocate a batch larger than total buffer memory.

3. Final Answer:

   Producer will block or throw an error when batch.size exceeds buffer.memory -> Option D

4. Quick Check:

   batch.size must be ≤ buffer.memory [OK]

Hint: batch.size cannot be bigger than buffer.memory [OK]

Common Mistakes:

• Assuming Kafka auto-corrects batch.size
• Expecting silent message drops
• Thinking config error happens at startup

5. You want to optimize Kafka producer for low latency and high throughput. Which combination of memory and buffer settings is best?

hard

A. Increase buffer.memory, decrease linger.ms, increase batch.size

B. Decrease buffer.memory, increase linger.ms, decrease batch.size

C. Keep buffer.memory small, set linger.ms high, increase batch.size

D. Set buffer.memory and batch.size low, linger.ms high

Solution

1. Step 1: Understand latency vs throughput tradeoff

   Low latency means sending data quickly, high throughput means sending large batches efficiently.

2. Step 2: Adjust buffer and batch settings accordingly

   Increasing buffer.memory and batch.size allows bigger batches, while decreasing linger.ms reduces wait time before sending.

3. Final Answer:

   Increase buffer.memory, decrease linger.ms, increase batch.size -> Option A

4. Quick Check:

   Big buffer + big batch + low linger = low latency & high throughput [OK]

Hint: Big buffer and batch, low linger for speed and volume [OK]

Common Mistakes:

• Increasing linger.ms reduces latency
• Decreasing buffer.memory improves throughput
• Setting batch.size too low for throughput