Error handling in streams in Kafka - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kafka Streams error handler code?

Consider the following Kafka Streams code snippet that uses a custom error handler. What will be printed when a deserialization error occurs?

Kafka

StreamsBuilder builder = new StreamsBuilder();

builder.stream("input-topic", Consumed.with(Serdes.String(), Serdes.String())
    .withErrorHandler((context, exception) -> {
        System.out.println("Error in topic: " + context.topic());
        return DeserializationHandlerResponse.CONTINUE;
    }))
    .to("output-topic");

KafkaStreams streams = new KafkaStreams(builder.build(), new Properties());
// Assume a deserialization error occurs on "input-topic"

A Exception thrown and stream stopped

B Error in topic: input-topic

C No output printed, error ignored silently

D Error in topic: output-topic

💡 Hint

Think about what the error handler prints and which topic it refers to.

The error handler prints the topic where the error happened, which is the input topic. It then returns CONTINUE, so the stream continues running.

🧠 Conceptual

intermediate

Which error handling strategy stops the Kafka Streams application on error?

Kafka Streams offers different error handling strategies. Which one will cause the application to stop processing when an error occurs?

A Log and continue processing

B Ignore errors silently

C Fail fast and stop the application

D Retry indefinitely without stopping

💡 Hint

Consider which strategy prioritizes safety by stopping on errors.

The 'fail fast' strategy stops the Kafka Streams application immediately when an error occurs to avoid inconsistent state.

🔧 Debug

advanced

Identify the error in this Kafka Streams error handler configuration

Review the following Kafka Streams error handler setup. What is the error that will cause a runtime failure?

Kafka

StreamsBuilder builder = new StreamsBuilder();

builder.stream("input-topic", Consumed.with(Serdes.String(), Serdes.String())
    .withErrorHandler((context, exception) -> {
        System.out.println("Error in topic: " + context.topic());
        return DeserializationHandlerResponse.FAIL;
    }))
    .to("output-topic");

KafkaStreams streams = new KafkaStreams(builder.build(), new Properties());
streams.start();

A The error handler returns FAIL but the stream is not closed properly, causing resource leaks

B The error handler lambda syntax is invalid, causing a compilation error

C The error handler returns an undefined enum value, causing a runtime exception

D The error handler does not handle exceptions, causing the stream to crash

💡 Hint

Think about what happens when FAIL is returned and how the stream lifecycle is managed.

Returning FAIL tells Kafka Streams to stop processing on error, but if the application does not close the stream properly, resources may leak.

📝 Syntax

advanced

Which option correctly configures a Kafka Streams error handler for deserialization errors?

Choose the code snippet that correctly sets a deserialization error handler in Kafka Streams.

A Consumed.with(Serdes.String(), Serdes.String()).withErrorHandler((context, ex) -> DeserializationHandlerResponse.CONTINUE);

B Consumed.with(Serdes.String(), Serdes.String()).withErrorHandler { context, ex -> DeserializationHandlerResponse.CONTINUE }

C Consumed.with(Serdes.String(), Serdes.String()).withErrorHandler((context, ex) -> { return DeserializationHandlerResponse.CONTINUE; });

D Consumed.with(Serdes.String(), Serdes.String()).withErrorHandler((context, ex) => DeserializationHandlerResponse.CONTINUE);

💡 Hint

Recall Java lambda syntax and method chaining style.

Option A uses correct Java lambda syntax and method chaining. Option A uses invalid syntax for Java. Option A misses a semicolon. Option A uses JavaScript arrow syntax, invalid in Java.

🚀 Application

expert

How many error handler invocations occur for a batch of 3 corrupted messages in Kafka Streams?

Assume a Kafka Streams application processes a batch of 3 messages, all corrupted causing deserialization errors. The error handler is set to CONTINUE after logging. How many times will the error handler be invoked?

A 1

B Depends on the number of partitions

C 0

D 3

💡 Hint

Think about how Kafka Streams processes each message and triggers error handlers.

The error handler is invoked once per corrupted message, so for 3 corrupted messages, it is called 3 times.