CONFIGURATION.md

Global configuration properties

Property	C/P	Default	Description
client.id	*	rdkafka	Client identifier.
metadata.broker.list	*		Initial list of brokers. The application may also use rd_kafka_brokers_add() to add brokers during runtime.
message.max.bytes	*	4000000	Maximum transmit message size.
receive.message.max.bytes	*	100000000	Maximum receive message size. This is a safety precaution to avoid memory exhaustion in case of protocol hickups. The value should be at least fetch.message.max.bytes * number of partitions consumed from + messaging overhead (e.g. 200000 bytes).
metadata.request.timeout.ms	*	60000	Non-topic request timeout in milliseconds. This is for metadata requests, etc.
topic.metadata.refresh.interval.ms	*	10000	Topic metadata refresh interval in milliseconds. The metadata is automatically refreshed on error and connect. Use -1 to disable the intervalled refresh.
topic.metadata.refresh.fast.cnt	*	10	When a topic looses its leader this number of metadata requests are sent with topic.metadata.refresh.fast.interval.ms interval disregarding the topic.metadata.refresh.interval.ms value. This is used to recover quickly from transitioning leader brokers.
topic.metadata.refresh.fast.interval.ms	*	250	See topic.metadata.refresh.fast.cnt description
topic.metadata.refresh.sparse	*	false	Sparse metadata requests (consumes less network bandwidth)
debug	*		A comma-separated list of debug contexts to enable: all,generic,broker,topic,metadata,producer,queue,msg,protocol
socket.timeout.ms	*	60000	Timeout for network requests.
socket.send.buffer.bytes	*	0	Broker socket send buffer size. System default is used if 0.
socket.receive.buffer.bytes	*	0	Broker socket receive buffer size. System default is used if 0.
socket.keepalive.enable	*	false	Enable TCP keep-alives (SO_KEEPALIVE) on broker sockets
socket.max.fails	*	3	Disconnect from broker when this number of send failures (e.g., timed out requests) is reached. Disable with 0. NOTE: The connection is automatically re-established.
broker.address.ttl	*	300000	How long to cache the broker address resolving results.
broker.address.family	*	any	Allowed broker IP address families: any, v4, v6
statistics.interval.ms	*	0	librdkafka statistics emit interval. The application also needs to register a stats callback using rd_kafka_conf_set_stats_cb(). The granularity is 1000ms. A value of 0 disables statistics.
error_cb	*		Error callback (set with rd_kafka_conf_set_error_cb())
stats_cb	*		Statistics callback (set with rd_kafka_conf_set_stats_cb())
log_cb	*		Log callback (set with rd_kafka_conf_set_log_cb())
log_level	*	6	Logging level (syslog(3) levels)
socket_cb	*		Socket creation callback to provide race-free CLOEXEC
open_cb	*		File open callback to provide race-free CLOEXEC
opaque	*		Application opaque (set with rd_kafka_conf_set_opaque())
internal.termination.signal	*	0	Signal that librdkafka will use to quickly terminate on rd_kafka_destroy(). If this signal is not set then there will be a delay before rd_kafka_wait_destroyed() returns true as internal threads are timing out their system calls. If this signal is set however the delay will be minimal. The application should mask this signal as an internal signal handler is installed.
queued.min.messages	C	100000	Minimum number of messages per topic+partition in the local consumer queue.
queued.max.messages.kbytes	C	1000000	Maximum number of kilobytes per topic+partition in the local consumer queue. This value may be overshot by fetch.message.max.bytes.
fetch.wait.max.ms	C	100	Maximum time the broker may wait to fill the response with fetch.min.bytes.
fetch.message.max.bytes	C	1048576	Maximum number of bytes per topic+partition to request when fetching messages from the broker.
fetch.min.bytes	C	1	Minimum number of bytes the broker responds with. If fetch.wait.max.ms expires the accumulated data will be sent to the client regardless of this setting.
fetch.error.backoff.ms	C	500	How long to postpone the next fetch request for a topic+partition in case of a fetch error.
group.id	C		Consumer group id string. All clients sharing the same group.id belong to the same consumer group.
queue.buffering.max.messages	P	100000	Maximum number of messages allowed on the producer queue.
queue.buffering.max.ms	P	1000	Maximum time, in milliseconds, for buffering data on the producer queue.
message.send.max.retries	P	2	How many times to retry sending a failing MessageSet. Note: retrying may cause reordering.
retry.backoff.ms	P	100	The backoff time in milliseconds before retrying a message send.
compression.codec	P	none	Compression codec to use for compressing message sets: none, gzip or snappy
batch.num.messages	P	1000	Maximum number of messages batched in one MessageSet.
delivery.report.only.error	P	false	Only provide delivery reports for failed messages.
dr_cb	P		Delivery report callback (set with rd_kafka_conf_set_dr_cb())
dr_msg_cb	P		Delivery report callback (set with rd_kafka_conf_set_dr_msg_cb())

Topic configuration properties

Property	C/P	Default	Description
request.required.acks	P	1	This field indicates how many acknowledgements the leader broker must receive from ISR brokers before responding to the request: 0=broker does not send any response, 1=broker will wait until the data is written to local log before sending a response, -1=broker will block until message is committed by all in sync replicas (ISRs) or broker's in.sync.replicas setting before sending response. 1=Only the leader broker will need to ack the message.
enforce.isr.cnt	P	0	Fail messages locally if the currently known ISR count for a partition is less than this value. NOTE: The ISR count is fetched from the broker at regular intervals (topic.metadata.refresh.interval.ms) and might thus be outdated.
request.timeout.ms	P	5000	The ack timeout of the producer request in milliseconds. This value is only enforced by the broker and relies on request.required.acks being > 0.
message.timeout.ms	P	300000	Local message timeout. This value is only enforced locally and limits the time a produced message waits for successful delivery. A time of 0 is infinite.
produce.offset.report	P	false	Report offset of produced message back to application. The application must be use the dr_msg_cb to retrieve the offset from rd_kafka_message_t.offset.
partitioner	P		Partitioner callback (set with rd_kafka_topic_conf_set_partitioner_cb())
opaque	*		Application opaque (set with rd_kafka_topic_conf_set_opaque())
group.id	C		Consumer group id string. All clients sharing the same group.id belong to the same consumer group. This takes precedence over the global group.id.
auto.commit.enable	C	true	If true, periodically commit offset of the last message handed to the application. This commited offset will be used when the process restarts to pick up where it left off. If false, the application will have to call rd_kafka_offset_store() to store an offset (optional). NOTE: There is currently no zookeeper integration, offsets will be written to broker or local file according to offset.store.method.
auto.commit.interval.ms	C	60000	The frequency in milliseconds that the consumer offsets are commited (written) to offset storage.
auto.offset.reset	C	largest	Action to take when there is no initial offset in offset store or the desired offset is out of range: 'smallest' - automatically reset the offset to the smallest offset, 'largest' - automatically reset the offset to the largest offset, 'error' - trigger an error which is retrieved by consuming messages and checking 'message->err'.
offset.store.path	C	.	Path to local file for storing offsets. If the path is a directory a filename will be automatically generated in that directory based on the topic and partition.
offset.store.sync.interval.ms	C	-1	fsync() interval for the offset file, in milliseconds. Use -1 to disable syncing, and 0 for immediate sync after each write.
offset.store.method	C	file	Offset commit store method: 'file' - local file store (offset.store.path, et.al), 'broker' - broker commit store (requires Apache Kafka 0.8.1 or later on the broker).
consume.callback.max.messages	C	0	Maximum number of messages to dispatch in one rd_kafka_consume_callback*() call (0 = unlimited)

C/P legend: C = Consumer, P = Producer, * = both