CCDAK Exam Dumps - Confluent Certified Developer for Apache Kafka Certification Examination

Kafka Connect sink connectors use the standard Kafka consumer mechanism to track offsets, which means offsets are stored in the __consumer_offsets internal topic.

From Kafka Connect Documentation:

“Sink connectors are regular Kafka consumers and store their offsets in the __consumer_offsets topic like any other consumer.”

The other options refer to source connectors or worker configuration.

offsets.storage.topic is relevant for source connectors.

According to the official Apache Kafka Connect documentation, RegexRouter is the SMT specifically designed to dynamically change the destination topic name of records produced by a connector. It works by applying a regular expression to the original topic name and rewriting it to a new topic name.

This makes RegexRouter the correct choice when some records must be routed to a different topic, typically in combination with connector-level logic, predicates, or multiple connectors. It is commonly used for topic renaming, topic versioning, or routing records to alternate topics.

InsertField (Option B) only adds metadata fields (such as topic, partition, or timestamp) to the record payload and does not affect routing. TombstoneHandler (Option C) is used to manage null-value records, especially with compacted topics. HeaderFrom (Option D) copies fields into headers but does not change the target topic.

Therefore, RegexRouter is the only SMT that directly supports changing the output topic, as documented in the Kafka Connect SMT reference.

=========================

According to the official Apache Kafka consumer semantics documentation, at-most-once delivery means that records may be lost but must never be processed more than once. To achieve this guarantee, a consumer must commit offsets before processing records. If the application crashes after committing but before processing, messages are skipped rather than reprocessed, which satisfies at-most-once semantics.

Option B correctly implements this pattern. It disables automatic offset commits (enable.auto.commit=false) and explicitly calls commitAsync() immediately after polling and before processing records. This ensures that offsets are advanced regardless of whether processing succeeds, eliminating the possibility of duplicate processing.

Option C represents at-least-once semantics, because offsets are committed after processing, which can lead to duplicates on failure. Options A and D rely on automatic commits or incorrect ordering and do not provide strict at-most-once guarantees.

The Kafka documentation explicitly states that manual offset management with commits before processing is required for at-most-once delivery.

Therefore, Option B is the best and officially documented configuration and code skeleton to avoid duplicate message processing.

The official Apache Kafka Streams developer documentation clearly states that TopologyTestDriver is the recommended and supported tool for unit testing Kafka Streams applications without requiring a running Kafka cluster. It is specifically designed to test complex topologies consisting of multiple sources, processors, state stores, sinks, and even sub-topologies.

TopologyTestDriver allows developers to instantiate the Kafka Streams topology directly in memory and feed test records into input topics while reading results from output topics. This makes it ideal for fast, deterministic, and isolated unit tests. As documented, it supports testing stateful and stateless operations, windowed aggregations, joins, and exactly-once behavior at the topology level.

Option A is incorrect because TestProducer and TestConsumer are not official Kafka Streams testing utilities. Option B is invalid because KafkaUnitTestDriver does not exist in Apache Kafka. Option D (MockProducer and MockConsumer) belongs to the Kafka Clients API and is suitable for producer/consumer testing, but it does not support Kafka Streams topologies or state stores.

Therefore, TopologyTestDriver is the only fully supported and officially documented solution for unit testing Kafka Streams applications without a real Kafka cluster.

The batch.size config sets the maximum number of bytes to batch per partition before sending. This allows Kafka producers to amortize I/O and improve throughput.

From Kafka Producer Configuration Docs:

“batch.size is the maximum amount of data per partition the producer will batch before sending.”

buffer.memory sets total memory for the producer, not per-batch.

send.buffer.bytes is a TCP socket buffer, not a Kafka config.

max.block.ms controls blocking time, not size.

max.poll.interval.ms defines the maximum delay between invocations of poll() before the consumer is considered failed. It essentially gives consumers more time to process records before needing to poll again.

From Kafka Consumer Configuration Reference:

“max.poll.interval.ms: The maximum delay between invocations of poll() when using consumer group management. If poll() is not called before expiration, the consumer is considered failed.”

session.timeout.ms and heartbeat.interval.ms relate to group coordination and heartbeats.

fetch.max.wait.ms affects how long the broker waits to accumulate data before sending a fetch response.

The onCompletion() method of Kafka’s Callback interface is executed once the broker acknowledges the message. This includes success or failure, and it is invoked asynchronously by the producer.

From Kafka Java Client API Documentation:

“The onCompletion method will be called when the record sent to the server has been acknowledged, or when an error occurs.”

This ensures that the record was sent and acknowledged, not just added to a batch or local buffer.

When a message key is specified in Kafka, the producer uses a partitioner (typically the default hash-based partitioner) to deterministically map all records with the same key to the same partition. Kafka guarantees order within a partition, so this enables per-key ordering.

From Kafka Producer Concepts:

“If a key is present, the producer will always route records with the same key to the same partition. Kafka preserves the order of records within a partition.”

This is essential for ordered processing and join semantics.