//! Kafka plus Kacrab runtime configuration catalog.
//!
//! @generated by `cargo run -p kacrab-codegen -- config`.
//! Do not hand-edit this file; update the snapshot/policy generator instead.
use super::metadata::{ClientKind, ConfigEntry, ConfigOrigin, ConfigStatus};
/// Pinned upstream Kafka config source used for this generated catalog.
pub const KAFKA_CONFIG_SOURCE_REF: &str = "apache/kafka@4.3.0";
/// Kafka 4.3 producer configuration metadata plus Kacrab runtime overlays.
pub const PRODUCER_CONFIGS: &[ConfigEntry] = &[
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "bootstrap.servers",
rust_field: "bootstrap_servers",
kafka_type: "list",
default: "(none)",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A list of host/port pairs used to establish the initial connection to the Kafka cluster. Clients use this list to bootstrap and discover the full set of Kafka brokers. While the order of servers in the list does not matter, we recommend including more than one server to ensure resilience if any servers are down. This list does not need to contain the entire set of brokers, as Kafka clients automatically manage and update connections to the cluster efficiently. This list must be in the form <code>host1:port1,host2:port2,...</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_bootstrap.servers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "client.dns.lookup",
rust_field: "client_dns_lookup",
kafka_type: "string",
default: "ClientDnsLookup.USE_ALL_DNS_IPS.toString()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client uses DNS lookups. If set to <code>use_all_dns_ips</code>, connect to each returned IP address in sequence until a successful connection is established. After a disconnection, the next IP is used. Once all IPs have been used once, the client resolves the IP(s) from the hostname again (both the JVM and the OS cache DNS name lookups, however). If set to <code>resolve_canonical_bootstrap_servers_only</code>, resolve each bootstrap address into a list of canonical names. After the bootstrap phase, this behaves the same as <code>use_all_dns_ips</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_client.dns.lookup",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "buffer.memory",
rust_field: "buffer_memory",
kafka_type: "long",
default: "32 * 1024 * 1024L",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The total bytes of memory the producer can use to buffer records waiting to be sent to the server. If records are sent faster than they can be delivered to the server the producer will block for <code>max.block.ms</code> after which it will fail with an exception.<p>This setting should correspond roughly to the total memory the producer will use, but is not a hard bound since not all memory the producer uses is used for buffering. Some additional memory will be used for compression (if compression is enabled) as well as for maintaining in-flight requests.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_buffer.memory",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "retries",
rust_field: "retries",
kafka_type: "int",
default: "Integer.MAX_VALUE",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Number of times to retry a request that fails with a transient error. Setting a value greater than zero will cause the client to resend any record whose send fails with a potentially transient error. Requests will be retried this many times until they succeed, fail with a non-transient error, or the <code>delivery.timeout.ms</code> expires. Note that this automatic retry will simply resend the same record upon receiving the error. Setting a value of zero will disable this automatic retry behaviour, so that the transient errors will be propagated to the application to be handled. Users should generally prefer to leave this config unset and instead use <code>delivery.timeout.ms</code> to control retry behavior.<p>Enabling idempotence requires this config value to be greater than 0. If conflicting configurations are set and idempotence is not explicitly enabled, idempotence is disabled.<p>Allowing retries while setting <code>enable.idempotence</code> to <code>false</code> and <code>max.in.flight.requests.per.connection</code> to greater than 1 will potentially change the ordering of records because if two batches are sent to a single partition, and the first fails and is retried but the second succeeds, then the records in the second batch may appear first.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_retries",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "acks",
rust_field: "acks",
kafka_type: "string",
default: "all",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The number of acknowledgments the producer requires the leader to have received before considering a request complete. This controls the durability of records that are sent. The following settings are allowed: <ul> <li><code>acks=0</code> If set to zero then the producer will not wait for any acknowledgment from the server at all. The record will be immediately added to the socket buffer and considered sent. No guarantee can be made that the server has received the record in this case, and the <code>retries</code> configuration will not take effect (as the client won't generally know of any failures). The offset given back for each record will always be set to <code>-1</code>. <li><code>acks=1</code> This will mean the leader will write the record to its local log but will respond without awaiting full acknowledgement from all followers. In this case should the leader fail immediately after acknowledging the record but before the followers have replicated it then the record will be lost. <li><code>acks=all</code> This means the leader will wait for the full set of in-sync replicas to acknowledge the record. This guarantees that the record will not be lost as long as at least one in-sync replica remains alive. This is the strongest available guarantee. This is equivalent to the acks=-1 setting.</ul><p>Note that enabling idempotence requires this config value to be 'all'. If conflicting configurations are set and idempotence is not explicitly enabled, idempotence is disabled.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_acks",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "compression.type",
rust_field: "compression_type",
kafka_type: "string",
default: "CompressionType.NONE.name",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The compression type for all data generated by the producer. The default is none (i.e. no compression). Valid values are <code>none</code>, <code>gzip</code>, <code>snappy</code>, <code>lz4</code>, or <code>zstd</code>. Compression is of full batches of data, so the efficacy of batching will also impact the compression ratio (more batching means better compression).",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_compression.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "compression.gzip.level",
rust_field: "compression_gzip_level",
kafka_type: "int",
default: "CompressionType.GZIP.defaultLevel()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The compression level to use if compression.type is set to <code>gzip</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_compression.gzip.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "compression.lz4.level",
rust_field: "compression_lz4_level",
kafka_type: "int",
default: "CompressionType.LZ4.defaultLevel()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The compression level to use if compression.type is set to <code>lz4</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_compression.lz4.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "compression.zstd.level",
rust_field: "compression_zstd_level",
kafka_type: "int",
default: "CompressionType.ZSTD.defaultLevel()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The compression level to use if compression.type is set to <code>zstd</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_compression.zstd.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "batch.size",
rust_field: "batch_size",
kafka_type: "int",
default: "16384",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The producer will attempt to batch records together into fewer requests whenever multiple records are being sent to the same partition. This helps performance on both the client and the server. This configuration controls the default batch size in bytes. <p>No attempt will be made to batch records larger than this size. <p>Requests sent to brokers will contain multiple batches, one for each partition with data available to be sent. <p>A small batch size will make batching less common and may reduce throughput (a batch size of zero will disable batching entirely). A very large batch size may use memory a bit more wastefully as we will always allocate a buffer of the specified batch size in anticipation of additional records.<p>Note: This setting gives the upper bound of the batch size to be sent. If we have fewer than this many bytes accumulated for this partition, we will 'linger' for the <code>linger.ms</code> time waiting for more records to show up. This <code>linger.ms</code> setting defaults to 5, which means the producer will wait for 5ms or until the record batch is of <code>batch.size</code> (whichever happens first) before sending the record batch. Note that broker backpressure can result in a higher effective linger time than this setting. The default changed from 0 to 5 in Apache Kafka 4.0 as the efficiency gains from larger batches typically result in similar or lower producer latency despite the increased linger.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_batch.size",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "partitioner.adaptive.partitioning.enable",
rust_field: "partitioner_adaptive_partitioning_enable",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "When set to 'true', the producer will try to adapt to broker performance and produce more messages to partitions hosted on faster brokers. If 'false', the producer will try to distribute messages uniformly. Note: this setting has no effect if a custom partitioner is used.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_partitioner.adaptive.partitioning.enable",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "partitioner.availability.timeout.ms",
rust_field: "partitioner_availability_timeout_ms",
kafka_type: "long",
default: "0",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If a broker cannot process produce requests from a partition for <code>partitioner.availability.timeout.ms</code> time, the partitioner treats that partition as not available. If the value is 0, this logic is disabled. Note: this setting has no effect if a custom partitioner is used or <code>partitioner.adaptive.partitioning.enable</code> is set to 'false'.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_partitioner.availability.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "partitioner.ignore.keys",
rust_field: "partitioner_ignore_keys",
kafka_type: "boolean",
default: "false",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "When set to 'true' the producer won't use record keys to choose a partition. If 'false', producer would choose a partition based on a hash of the key when a key is present. Note: this setting has no effect if a custom partitioner is used.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_partitioner.ignore.keys",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "linger.ms",
rust_field: "linger_ms",
kafka_type: "long",
default: "5",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The producer groups together any records that arrive in between request transmissions into a single batched request. Normally this occurs only under load when records arrive faster than they can be sent out. However in some circumstances the client may want to reduce the number of requests even under moderate load. This setting accomplishes this by adding a small amount of artificial delay—that is, rather than immediately sending out a record, the producer will wait for up to the given delay to allow other records to be sent so that the sends can be batched together. This can be thought of as analogous to Nagle's algorithm in TCP. This setting gives the upper bound on the delay for batching: once we get <code>batch.size</code> worth of records for a partition it will be sent immediately regardless of this setting, however if we have fewer than this many bytes accumulated for this partition we will 'linger' for the specified time waiting for more records to show up. This setting defaults to 5 (i.e. 5ms delay). Increasing <code>linger.ms=50</code>, for example, would have the effect of reducing the number of requests sent but would add up to 50ms of latency to records sent in the absence of load.The default changed from 0 to 5 in Apache Kafka 4.0 as the efficiency gains from larger batches typically result in similar or lower producer latency despite the increased linger.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_linger.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "delivery.timeout.ms",
rust_field: "delivery_timeout_ms",
kafka_type: "int",
default: "120 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "An upper bound on the time to report success or failure after a call to <code>send()</code> returns. This limits the total time that a record will be delayed prior to sending, the time to await acknowledgement from the broker (if expected), and the time allowed for retriable send failures. The producer may report failure to send a record earlier than this config if either an unrecoverable error is encountered, the retries have been exhausted, or the record is added to a batch which reached an earlier delivery expiration deadline. The value of this config should be greater than or equal to the sum of <code>request.timeout.ms</code> and <code>linger.ms</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_delivery.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "client.id",
rust_field: "client_id",
kafka_type: "string",
default: "",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "An id string to pass to the server when making requests. The purpose of this is to be able to track the source of requests beyond just ip/port by allowing a logical application name to be included in server-side request logging.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "send.buffer.bytes",
rust_field: "send_buffer_bytes",
kafka_type: "int",
default: "128 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP send buffer (SO_SNDBUF) to use when sending data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_send.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "receive.buffer.bytes",
rust_field: "receive_buffer_bytes",
kafka_type: "int",
default: "32 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP receive buffer (SO_RCVBUF) to use when reading data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_receive.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "max.request.size",
rust_field: "max_request_size",
kafka_type: "int",
default: "1024 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum size of a request in bytes. This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. This is also effectively a cap on the maximum uncompressed record batch size. Note that the server has its own cap on the record batch size (after compression if compression is enabled) which may be different from this.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_max.request.size",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.ms",
rust_field: "reconnect_backoff_ms",
kafka_type: "long",
default: "50L",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The base amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all connection attempts by the client to a broker. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>reconnect.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_reconnect.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.max.ms",
rust_field: "reconnect_backoff_max_ms",
kafka_type: "long",
default: "1000L",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_reconnect.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.ms",
rust_field: "retry_backoff_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The amount of time to wait before attempting to retry a failed request to a given topic partition. This avoids repeatedly sending requests in a tight loop under some failure scenarios. This value is the initial backoff value and will increase exponentially for each failed request, up to the <code>retry.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.max.ms",
rust_field: "retry_backoff_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time in milliseconds to wait when retrying a request to the broker that has repeatedly failed. If provided, the backoff per client will increase exponentially for each failed request, up to this maximum. To prevent all clients from being synchronized upon retry, a randomized jitter with a factor of 0.2 will be applied to the backoff, resulting in the backoff falling within a range between 20% below and 20% above the computed value. If <code>retry.backoff.ms</code> is set to be higher than <code>retry.backoff.max.ms</code>, then <code>retry.backoff.max.ms</code> will be used as a constant backoff from the beginning without any exponential increase",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "enable.metrics.push",
rust_field: "enable_metrics_push",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Whether to enable pushing of client metrics to the cluster, if the cluster has a client metrics subscription which matches this client.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_enable.metrics.push",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "max.block.ms",
rust_field: "max_block_ms",
kafka_type: "long",
default: "60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The configuration controls how long the <code>KafkaProducer</code>'s <code>send()</code>, <code>partitionsFor()</code>, <code>initTransactions()</code>, <code>sendOffsetsToTransaction()</code>, <code>commitTransaction()</code> and <code>abortTransaction()</code> methods will block. For <code>send()</code> this timeout bounds the total time waiting for both metadata fetch and buffer allocation (blocking in the user-supplied serializers or partitioner is not counted against this timeout). For <code>partitionsFor()</code> this timeout bounds the time spent waiting for metadata if it is unavailable. The transaction-related methods always block, but may timeout if the transaction coordinator could not be discovered or did not respond within the timeout.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_max.block.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "request.timeout.ms",
rust_field: "request_timeout_ms",
kafka_type: "int",
default: "30 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted. This should be larger than <code>replica.lag.time.max.ms</code> (a broker configuration) to reduce the possibility of message duplication due to unnecessary producer retries.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_request.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metadata.max.age.ms",
rust_field: "metadata_max_age_ms",
kafka_type: "long",
default: "5 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metadata.max.age.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metadata.max.idle.ms",
rust_field: "metadata_max_idle_ms",
kafka_type: "long",
default: "5 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how long the producer will cache metadata for a topic that's idle. If the elapsed time since a topic was last produced to exceeds the metadata idle duration, then the topic's metadata is forgotten and the next access to it will force a metadata fetch request.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metadata.max.idle.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metrics.sample.window.ms",
rust_field: "metrics_sample_window_ms",
kafka_type: "long",
default: "30000",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The window of time a metrics sample is computed over.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metrics.sample.window.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metrics.num.samples",
rust_field: "metrics_num_samples",
kafka_type: "int",
default: "2",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The number of samples maintained to compute metrics.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metrics.num.samples",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metrics.recording.level",
rust_field: "metrics_recording_level",
kafka_type: "string",
default: "Sensor.RecordingLevel.INFO.toString()",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The highest recording level for metrics. It has three levels for recording metrics - info, debug, and trace.\n \nINFO level records only essential metrics necessary for monitoring system performance and health. It collects vital data without gathering too much detail, making it suitable for production environments where minimal overhead is desired.\n\nDEBUG level records most metrics, providing more detailed information about the system's operation. It's useful for development and testing environments where you need deeper insights to debug and fine-tune the application.\n\nTRACE level records all possible metrics, capturing every detail about the system's performance and operation. It's best for controlled environments where in-depth analysis is required, though it can introduce significant overhead.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metrics.recording.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metric.reporters",
rust_field: "metric_reporters",
kafka_type: "list",
default: "JmxReporter.class.getName()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of classes to use as metrics reporters. Implementing the <code>org.apache.kafka.common.metrics.MetricsReporter</code> interface allows plugging in classes that will be notified of new metric creation. When custom reporters are set and <code>org.apache.kafka.common.metrics.JmxReporter</code> is needed, it has to be explicitly added to the list.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metric.reporters",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "max.in.flight.requests.per.connection",
rust_field: "max_in_flight_requests_per_connection",
kafka_type: "int",
default: "5",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum number of unacknowledged requests the client will send on a single connection before blocking. Note that if this configuration is set to be greater than 1 and <code>enable.idempotence</code> is set to false, there is a risk of message reordering after a failed send due to retries (i.e., if retries are enabled); if retries are disabled or if <code>enable.idempotence</code> is set to true, ordering will be preserved. Additionally, enabling idempotence requires the value of this configuration to be less than or equal to 5, because broker only retains at most 5 batches for each producer. If the value is more than 5, previous batches may be removed on broker side.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_max.in.flight.requests.per.connection",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "key.serializer",
rust_field: "key_serializer",
kafka_type: "class",
default: "(none)",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Serializer class for key that implements the <code>org.apache.kafka.common.serialization.Serializer</code> interface.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_key.serializer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "value.serializer",
rust_field: "value_serializer",
kafka_type: "class",
default: "(none)",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Serializer class for value that implements the <code>org.apache.kafka.common.serialization.Serializer</code> interface.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_value.serializer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.ms",
rust_field: "socket_connection_setup_timeout_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The amount of time the client will wait for the socket connection to be established. If the connection is not built before the timeout elapses, clients will close the socket channel. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>socket.connection.setup.timeout.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_socket.connection.setup.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.max.ms",
rust_field: "socket_connection_setup_timeout_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time the client will wait for the socket connection to be established. The connection setup timeout will increase exponentially for each consecutive connection failure up to this maximum. To avoid connection storms, a randomization factor of 0.2 will be applied to the timeout resulting in a random range between 20% below and 20% above the computed value.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_socket.connection.setup.timeout.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "connections.max.idle.ms",
rust_field: "connections_max_idle_ms",
kafka_type: "long",
default: "9 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Close idle connections after the number of milliseconds specified by this config.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_connections.max.idle.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "partitioner.class",
rust_field: "partitioner_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Determines which partition to send a record to when records are produced. Available options are:<ul><li>If not set, the default partitioning logic is used. This strategy send records to a partition until at least batch.size bytes is produced to the partition. It works with the strategy:<ol><li>If no partition is specified but a key is present, choose a partition based on a hash of the key.</li><li>If no partition or key is present, choose the sticky partition that changes when at least batch.size bytes are produced to the partition.</li></ol></li><li><code>org.apache.kafka.clients.producer.RoundRobinPartitioner</code>: A partitioning strategy where each record in a series of consecutive records is sent to a different partition, regardless of whether the 'key' is provided or not, until partitions run out and the process starts over again. Note: There's a known issue that will cause uneven distribution when a new batch is created. See KAFKA-9965 for more detail.</li></ul><p>Implementing the <code>org.apache.kafka.clients.producer.Partitioner</code> interface allows you to plug in a custom partitioner.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_partitioner.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "interceptor.classes",
rust_field: "interceptor_classes",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of classes to use as interceptors. Implementing the <code>org.apache.kafka.clients.producer.ProducerInterceptor</code> interface allows you to intercept (and possibly mutate) the records received by the producer before they are published to the Kafka cluster. By default, there are no interceptors.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_interceptor.classes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "security.protocol",
rust_field: "security_protocol",
kafka_type: "string",
default: "CommonClientConfigs.DEFAULT_SECURITY_PROTOCOL",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "Protocol used to communicate with brokers.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_security.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "security.providers",
rust_field: "security_providers",
kafka_type: "string",
default: "null",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of configurable creator classes each returning a provider implementing security algorithms. These classes should implement the <code>org.apache.kafka.common.security.auth.SecurityProviderCreator</code> interface.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_security.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "enable.idempotence",
rust_field: "enable_idempotence",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "When set to 'true', the producer will ensure that exactly one copy of each message is written in the stream. If 'false', producer retries due to broker failures, etc., may write duplicates of the retried message in the stream. Note that enabling idempotence requires <code>max.in.flight.requests.per.connection</code> to be less than or equal to 5 (with message ordering preserved for any allowable value), <code>retries</code> to be greater than 0, and <code>acks</code> must be 'all'. <p>Idempotence is enabled by default if no conflicting configurations are set. If conflicting configurations are set and idempotence is not explicitly enabled, idempotence is disabled. If idempotence is explicitly enabled and conflicting configurations are set, a <code>ConfigException</code> is thrown.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_enable.idempotence",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "transaction.timeout.ms",
rust_field: "transaction_timeout_ms",
kafka_type: "int",
default: "60000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time in milliseconds that a transaction will remain open before the coordinator proactively aborts it. The start of the transaction is set at the time that the first partition is added to it. If this value is larger than the <code>transaction.max.timeout.ms</code> setting in the broker, the request will fail with a <code>InvalidTxnTimeoutException</code> error.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_transaction.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "transactional.id",
rust_field: "transactional_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The TransactionalId to use for transactional delivery. This enables reliability semantics which span multiple producer sessions since it allows the client to guarantee that transactions using the same TransactionalId have been completed prior to starting any new transactions. If no TransactionalId is provided, then the producer is limited to idempotent delivery. If a TransactionalId is configured, <code>enable.idempotence</code> is implied. By default the TransactionId is not configured, which means transactions cannot be used. Note that, by default, transactions require a cluster of at least three brokers which is the recommended setting for production; for development you can change this, by adjusting broker setting <code>transaction.state.log.replication.factor</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_transactional.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "transaction.two.phase.commit.enable",
rust_field: "transaction_two_phase_commit_enable",
kafka_type: "boolean",
default: "false",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If set to true, then the broker is informed that the client is participating in two phase commit protocol and transactions that this client starts never expire.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_transaction.two.phase.commit.enable",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.strategy",
rust_field: "metadata_recovery_strategy",
kafka_type: "string",
default: "CommonClientConfigs.DEFAULT_METADATA_RECOVERY_STRATEGY",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client recovers when none of the brokers known to it is available. If set to <code>none</code>, the client fails. If set to <code>rebootstrap</code>, the client repeats the bootstrap process using <code>bootstrap.servers</code>. Rebootstrapping is useful when a client communicates with brokers so infrequently that the set of brokers may change entirely before the client refreshes metadata. Metadata recovery is triggered when all last-known brokers appear unavailable simultaneously. Brokers appear unavailable when disconnected and no current retry attempt is in-progress. Consider increasing <code>reconnect.backoff.ms</code> and <code>reconnect.backoff.max.ms</code> and decreasing <code>socket.connection.setup.timeout.ms</code> and <code>socket.connection.setup.timeout.max.ms</code> for the client. Rebootstrap is also triggered if connection cannot be established to any of the brokers for <code>metadata.recovery.rebootstrap.trigger.ms</code> milliseconds or if server requests rebootstrap.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metadata.recovery.strategy",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.rebootstrap.trigger.ms",
rust_field: "metadata_recovery_rebootstrap_trigger_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_METADATA_RECOVERY_REBOOTSTRAP_TRIGGER_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If a client configured to rebootstrap using <code>metadata.recovery.strategy=rebootstrap</code> is unable to obtain metadata from any of the brokers in the last known metadata for this interval, client repeats the bootstrap process using <code>bootstrap.servers</code> configuration.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metadata.recovery.rebootstrap.trigger.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "config.providers",
rust_field: "config_providers",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Comma-separated alias names for classes implementing the <code>ConfigProvider</code> interface. This enables loading configuration data (such as passwords, API keys, and other credentials) from external sources. For example, see <a href=\"https://kafka.apache.org/documentation/#config_providers\">Configuration Providers</a>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_config.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.protocol",
rust_field: "ssl_protocol",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_PROTOCOL",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SSL protocol used to generate the SSLContext. The default is 'TLSv1.3', which should be fine for most use cases. A typical alternative to the default is 'TLSv1.2'. Allowed values for this config are dependent on the JVM. Clients using the defaults for this config and 'ssl.enabled.protocols' will downgrade to 'TLSv1.2' if the server does not support 'TLSv1.3'. If this config is set to 'TLSv1.2', however, clients will not use 'TLSv1.3' even if it is one of the values in <code>ssl.enabled.protocols</code> and the server only supports 'TLSv1.3'.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.provider",
rust_field: "ssl_provider",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The name of the security provider used for SSL connections. Default value is the default security provider of the JVM.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.provider",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.cipher.suites",
rust_field: "ssl_cipher_suites",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "A list of cipher suites. This is a named combination of authentication, encryption, MAC and key exchange algorithm used to negotiate the security settings for a network connection using TLS or SSL network protocol. By default all the available cipher suites are supported.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.cipher.suites",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.enabled.protocols",
rust_field: "ssl_enabled_protocols",
kafka_type: "list",
default: "SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The list of protocols enabled for SSL connections. The default is 'TLSv1.2,TLSv1.3'. This means that clients and servers will prefer TLSv1.3 if both support it and fallback to TLSv1.2 otherwise (assuming both support at least TLSv1.2). This default should be fine for most use cases. If this configuration is set to an empty list, Kafka will use the protocols enabled by default in the underlying SSLEngine, which may include additional protocols depending on the JVM version. Also see the config documentation for <code>ssl.protocol</code> to understand how it can impact the TLS version negotiation behavior.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.enabled.protocols",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.type",
rust_field: "ssl_keystore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the key store file. This is optional for client. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keystore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.location",
rust_field: "ssl_keystore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the key store file. This is optional for client and can be used for two-way authentication for client.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keystore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.password",
rust_field: "ssl_keystore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The store password for the key store file. This is optional for client and only needed if 'ssl.keystore.location' is configured. Key store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keystore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.key.password",
rust_field: "ssl_key_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password of the private key in the key store file or the PEM key specified in 'ssl.keystore.key'.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.key.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.key",
rust_field: "ssl_keystore_key",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Private key in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with PKCS#8 keys. If the key is encrypted, key password must be specified using 'ssl.key.password'",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keystore.key",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.certificate.chain",
rust_field: "ssl_keystore_certificate_chain",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Certificate chain in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with a list of X.509 certificates",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keystore.certificate.chain",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.certificates",
rust_field: "ssl_truststore_certificates",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Trusted certificates in the format specified by 'ssl.truststore.type'. Default SSL engine factory supports only PEM format with X.509 certificates.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.truststore.certificates",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.type",
rust_field: "ssl_truststore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the trust store file. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.truststore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.location",
rust_field: "ssl_truststore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the trust store file.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.truststore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.password",
rust_field: "ssl_truststore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password for the trust store file. If a password is not set, trust store file configured will still be used, but integrity checking is disabled. Trust store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.truststore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keymanager.algorithm",
rust_field: "ssl_keymanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keymanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.trustmanager.algorithm",
rust_field: "ssl_trustmanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.trustmanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.endpoint.identification.algorithm",
rust_field: "ssl_endpoint_identification_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The endpoint identification algorithm to validate server hostname using server certificate. ",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.endpoint.identification.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.secure.random.implementation",
rust_field: "ssl_secure_random_implementation",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SecureRandom PRNG implementation to use for SSL cryptography operations. ",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.secure.random.implementation",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.engine.factory.class",
rust_field: "ssl_engine_factory_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The class of type org.apache.kafka.common.security.auth.SslEngineFactory to provide SSLEngine objects. Default value is org.apache.kafka.common.security.ssl.DefaultSslEngineFactory. Alternatively, setting this to org.apache.kafka.common.security.ssl.CommonNameLoggingSslEngineFactory will log the common name of expired SSL certificates used by clients to authenticate at any of the brokers with log level INFO. Note that this will cause a tiny delay during establishment of new connections from mTLS clients to brokers due to the extra code for examining the certificate chain provided by the client. Note further that the implementation uses a custom truststore based on the standard Java truststore and thus might be considered a security risk due to not being as mature as the standard one.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.engine.factory.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.service.name",
rust_field: "sasl_kerberos_service_name",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The Kerberos principal name that Kafka runs as. This can be defined either in Kafka's JAAS config or in Kafka's config.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.kerberos.service.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.kinit.cmd",
rust_field: "sasl_kerberos_kinit_cmd",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_KERBEROS_KINIT_CMD",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Kerberos kinit command path.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.kerberos.kinit.cmd",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.window.factor",
rust_field: "sasl_kerberos_ticket_renew_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread will sleep until the specified window factor of time from last refresh to ticket's expiry has been reached, at which time it will try to renew the ticket.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.kerberos.ticket.renew.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.jitter",
rust_field: "sasl_kerberos_ticket_renew_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Percentage of random jitter added to the renewal time.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.kerberos.ticket.renew.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.min.time.before.relogin",
rust_field: "sasl_kerberos_min_time_before_relogin",
kafka_type: "long",
default: "SaslConfigs.DEFAULT_KERBEROS_MIN_TIME_BEFORE_RELOGIN",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread sleep time between refresh attempts.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.kerberos.min.time.before.relogin",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.factor",
rust_field: "sasl_login_refresh_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login refresh thread will sleep until the specified window factor relative to the credential's lifetime has been reached, at which time it will try to refresh the credential. Legal values are between 0.5 (50%) and 1.0 (100%) inclusive; a default value of 0.8 (80%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.refresh.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.jitter",
rust_field: "sasl_login_refresh_window_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The maximum amount of random jitter relative to the credential's lifetime that is added to the login refresh thread's sleep time. Legal values are between 0 and 0.25 (25%) inclusive; a default value of 0.05 (5%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.refresh.window.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.min.period.seconds",
rust_field: "sasl_login_refresh_min_period_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_MIN_PERIOD_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The desired minimum time for the login refresh thread to wait before refreshing a credential, in seconds. Legal values are between 0 and 900 (15 minutes); a default value of 60 (1 minute) is used if no value is specified. This value and sasl.login.refresh.buffer.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.refresh.min.period.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.buffer.seconds",
rust_field: "sasl_login_refresh_buffer_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_BUFFER_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The amount of buffer time before credential expiration to maintain when refreshing a credential, in seconds. If a refresh would otherwise occur closer to expiration than the number of buffer seconds then the refresh will be moved up to maintain as much of the buffer time as possible. Legal values are between 0 and 3600 (1 hour); a default value of 300 (5 minutes) is used if no value is specified. This value and sasl.login.refresh.min.period.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.refresh.buffer.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.mechanism",
rust_field: "sasl_mechanism",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_SASL_MECHANISM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "SASL mechanism used for client connections. This may be any mechanism for which a security provider is available. GSSAPI is the default mechanism.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.mechanism",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.jaas.config",
rust_field: "sasl_jaas_config",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "JAAS login context parameters for SASL connections in the format used by JAAS configuration files. JAAS configuration file format is described <a href=\"https://docs.oracle.com/javase/8/docs/technotes/guides/security/jgss/tutorials/LoginConfigFile.html\">here</a>. The format for the value is: <code>loginModuleClass controlFlag (optionName=optionValue)*;</code>. For brokers, the config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.jaas.config=com.example.ScramLoginModule required;",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.jaas.config",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.client.callback.handler.class",
rust_field: "sasl_client_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL client callback handler class that implements the AuthenticateCallbackHandler interface.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.client.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.callback.handler.class",
rust_field: "sasl_login_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL login callback handler class that implements the AuthenticateCallbackHandler interface. For brokers, login callback handler config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.callback.handler.class=com.example.CustomScramLoginCallbackHandler",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.class",
rust_field: "sasl_login_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a class that implements the Login interface. For brokers, login config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.class=com.example.CustomScramLogin",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.connect.timeout.ms",
rust_field: "sasl_login_connect_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider connection timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.connect.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.read.timeout.ms",
rust_field: "sasl_login_read_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider read timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.read.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.max.ms",
rust_field: "sasl_login_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.ms",
rust_field: "sasl_login_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.retriever.class",
rust_field: "sasl_oauthbearer_jwt_retriever_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_RETRIEVER_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtRetriever</code> implementation used to request tokens from the identity provider.</p><p>The default configuration value represents a class that maintains backward compatibility with previous versions of Apache Kafka. The default implementation uses the configuration to determine which concrete implementation to create.<p>Other implementations that are provided include:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.ClientCredentialsJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.FileJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.JwtBearerJwtRetriever</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwt.retriever.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.validator.class",
rust_field: "sasl_oauthbearer_jwt_validator_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_VALIDATOR_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtValidator</code> implementation used to validate the JWT from the identity provider.</p><p>The default validator (<code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code>) maintains backward compatibility with previous versions of Apache Kafka. The default validator uses configuration to determine which concrete implementation to create.<p>The built-in <code>JwtValidator</code> implementations are:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.BrokerJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.ClientJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwt.validator.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope",
rust_field: "sasl_oauthbearer_scope",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This is the level of access a client application is granted to a resource or API which is included in the token request. If provided, it should match one or more scopes configured in the identity provider.</p><p>The scope was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>scope</code>. For backward compatibility, the <code>scope</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.scope</code> from configuration</li><li><code>scope</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.scope",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.id",
rust_field: "sasl_oauthbearer_client_credentials_client_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The ID (defined in/by the OAuth identity provider) to identify the client requesting the token.</p><p>The client ID was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientId</code>. For backward compatibility, the <code>clientId</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.id</code> from configuration</li><li><code>clientId</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.client.credentials.client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.secret",
rust_field: "sasl_oauthbearer_client_credentials_client_secret",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The secret (defined by either the user or preassigned, depending on the identity provider) of the client requesting the token.</p><p>The client secret was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientSecret</code>. For backward compatibility, the <code>clientSecret</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.secret</code> from configuration</li><li><code>clientSecret</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.client.credentials.client.secret",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.algorithm",
rust_field: "sasl_oauthbearer_assertion_algorithm",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The algorithm the Apache Kafka client should use to sign the assertion sent to the identity provider. It is also used as the value of the OAuth <code>alg</code> (Algorithm) header in the JWT assertion.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.aud",
rust_field: "sasl_oauthbearer_assertion_claim_aud",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The JWT <code>aud</code> (Audience) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.aud",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.exp.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_exp_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_EXP_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the future</em> for which the JWT is valid. The value is used to determine the JWT <code>exp</code> (Expiration) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>exp</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n exp = x + y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.exp.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.iss",
rust_field: "sasl_oauthbearer_assertion_claim_iss",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>iss</code> (Issuer) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.iss",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.jti.include",
rust_field: "sasl_oauthbearer_assertion_claim_jti_include",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_JTI_INCLUDE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>Flag that determines if the JWT assertion should generate a unique ID for the JWT and include it in the <code>jti</code> (JWT ID) claim.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.jti.include",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.nbf.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_nbf_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_NBF_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the past</em> from which the JWT is valid. The value is used to determine the JWT <code>nbf</code> (Not Before) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>nbf</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n nbf = x - y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.nbf.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.sub",
rust_field: "sasl_oauthbearer_assertion_claim_sub",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>sub</code> (Subject) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.sub",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.file",
rust_field: "sasl_oauthbearer_assertion_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a <em>pre-generated</em> JWT assertion.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect whenthe file changes to allow for the file to be reloaded on modifications. This allows for "live" assertion rotation without restarting the Kafka client.</p><p>The file contains the assertion in the serialized, three part JWT format:</p><ol><li>The <em>header</em> section is a base 64-encoded JWT header that contains values like <code>alg</code> (Algorithm), <code>typ</code> (Type, always the literal value <code>JWT</code>), etc.</li><li>The <em>payload</em> section includes the base 64-encoded set of JWT claims, such as <code>aud</code> (Audience), <code>iss</code> (Issuer), <code>sub</code> (Subject), etc.</li><li>The <em>signature</em> section is the concatenated <em>header</em> and <em>payload</em> sections that was signed using a private key</li></ol><p>See <a href=\"https://datatracker.ietf.org/doc/html/rfc7519\">RFC 7519</a> and <a href=\"https://datatracker.ietf.org/doc/html/rfc7515\">RFC 7515</a> for more details on the JWT and JWS formats.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, all other <code>sasl.oauthbearer.assertion.</code>* configurations are ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.file",
rust_field: "sasl_oauthbearer_assertion_private_key_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a private key in the standard PEM format which is used to sign the JWT assertion sent to the identity provider.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect when the file changes to allow for the file to be reloaded on modifications. This allows for "live" private key rotation without restarting the Kafka client.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.private.key.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.passphrase",
rust_field: "sasl_oauthbearer_assertion_private_key_passphrase",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The optional passphrase to decrypt the private key file specified by <code>sasl.oauthbearer.assertion.private.key.file</code>.</p><p><em>Note</em>: If the file referred to by <code>sasl.oauthbearer.assertion.private.key.file</code> is modified on the file system at runtime and it was created with a <em>different</em> passphrase than it was previously, the client will not be able to access the private key file because the passphrase is now out of date. For that reason, when using private key passphrases, either use the same passphrase each time, or—for improved security—restart the Kafka client using the new passphrase configuration.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.private.key.passphrase",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.template.file",
rust_field: "sasl_oauthbearer_assertion_template_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This optional configuration specifies the file containing the JWT headers and/or payload claims to be used when creating the JWT assertion.</p><p>Not all identity providers require the same set of claims; some may require a given claim while others may prohibit it. In order to provide the most flexibility, this configuration allows the user to provide the static header values and claims that are to be included in the JWT.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.template.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope.claim.name",
rust_field: "sasl_oauthbearer_scope_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SCOPE_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the scope is often named \"scope\", but this (optional) setting can provide a different name to use for the scope included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.scope.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.sub.claim.name",
rust_field: "sasl_oauthbearer_sub_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SUB_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the subject is often named \"sub\", but this (optional) setting can provide a different name to use for the subject included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.sub.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.token.endpoint.url",
rust_field: "sasl_oauthbearer_token_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The URL for the OAuth/OIDC identity provider. If the URL is HTTP(S)-based, it is the issuer's token endpoint URL to which requests will be made to login based on the configuration in <code>sasl.oauthbearer.jwt.retriever.class</code>. If the URL is file-based, it specifies a file containing an access token (in JWT serialized form) issued by the OAuth/OIDC identity provider to use for authorization.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.token.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.url",
rust_field: "sasl_oauthbearer_jwks_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth/OIDC provider URL from which the provider's <a href=\"https://datatracker.ietf.org/doc/html/rfc7517#section-5\">JWKS (JSON Web Key Set)</a> can be retrieved. The URL can be HTTP(S)-based or file-based. If the URL is HTTP(S)-based, the JWKS data will be retrieved from the OAuth/OIDC provider via the configured URL on broker startup. All then-current keys will be cached on the broker for incoming requests. If an authentication request is received for a JWT that includes a \"kid\" header claim value that isn't yet in the cache, the JWKS endpoint will be queried again on demand. However, the broker polls the URL every sasl.oauthbearer.jwks.endpoint.refresh.ms milliseconds to refresh the cache with any forthcoming keys before any JWT requests that include them are received. If the URL is file-based, the broker will load the JWKS file from a configured location on startup. In the event that the JWT includes a \"kid\" header value that isn't in the JWKS file, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwks.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.refresh.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_refresh_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the broker to wait between refreshing its JWKS (JSON Web Key Set) cache that contains the keys to verify the signature of the JWT.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwks.endpoint.refresh.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between attempts to retrieve the JWKS (JSON Web Key Set) from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between JWKS (JSON Web Key Set) retrieval attempts from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.clock.skew.seconds",
rust_field: "sasl_oauthbearer_clock_skew_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in seconds to allow for differences between the time of the OAuth/OIDC identity provider and the broker.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.clock.skew.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.audience",
rust_field: "sasl_oauthbearer_expected_audience",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. The JWT will be inspected for the standard OAuth \"aud\" claim and if this value is set, the broker will match the value from JWT's \"aud\" claim to see if there is an exact match. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.expected.audience",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.issuer",
rust_field: "sasl_oauthbearer_expected_issuer",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting for the broker to use to verify that the JWT was created by the expected issuer. The JWT will be inspected for the standard OAuth \"iss\" claim and if this value is set, the broker will match it exactly against what is in the JWT's \"iss\" claim. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.expected.issuer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.header.urlencode",
rust_field: "sasl_oauthbearer_header_urlencode",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_HEADER_URLENCODE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting to enable the OAuth client to URL-encode the client_id and client_secret in the authorization header in accordance with RFC6749, see <a href=\"https://datatracker.ietf.org/doc/html/rfc6749#section-2.3.1\">here</a> for more details. The default value is set to 'false' for backward compatibility",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.header.urlencode",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.nodelay",
rust_field: "socket_tcp_nodelay",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets TCP_NODELAY on broker TCP connections.",
source: "kacrab-runtime://config/socket.tcp.nodelay",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.quickack",
rust_field: "socket_tcp_quickack",
kafka_type: "boolean",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_QUICKACK after a broker TCP connection is established.",
source: "kacrab-runtime://config/socket.tcp.quickack",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.notsent.lowat.bytes",
rust_field: "socket_tcp_notsent_lowat_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android.",
documentation: "Sets TCP_NOTSENT_LOWAT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.notsent.lowat.bytes",
platforms: &["linux", "android"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.user.timeout.ms",
rust_field: "socket_tcp_user_timeout_ms",
kafka_type: "long",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_USER_TIMEOUT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.user.timeout.ms",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.congestion",
rust_field: "socket_tcp_congestion",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, freebsd.",
documentation: "Sets the TCP congestion-control algorithm on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.congestion",
platforms: &["linux", "freebsd"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.reuse.address",
rust_field: "socket_reuse_address",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets SO_REUSEADDR before connecting broker TCP sockets.",
source: "kacrab-runtime://config/socket.reuse.address",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.read.buffer.capacity.bytes",
rust_field: "socket_read_buffer_capacity_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime option generated from the runtime config overlay.",
documentation: "Initial reusable in-process read buffer capacity for broker frame reads.",
source: "kacrab-runtime://config/socket.read.buffer.capacity.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "broker.queue.capacity",
rust_field: "broker_queue_capacity",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime option generated from the runtime config overlay.",
documentation: "Bounded pending command queue capacity for each broker IO task.",
source: "kacrab-runtime://config/broker.queue.capacity",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "buffer.pool.capacity",
rust_field: "buffer_pool_capacity",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime option generated from the runtime config overlay.",
documentation: "Number of reusable wire read/write buffers retained per client.",
source: "kacrab-runtime://config/buffer.pool.capacity",
platforms: &[],
feature: None,
},
];
/// Kafka 4.3 consumer configuration metadata plus Kacrab runtime overlays.
pub const CONSUMER_CONFIGS: &[ConfigEntry] = &[
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "bootstrap.servers",
rust_field: "bootstrap_servers",
kafka_type: "list",
default: "(none)",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A list of host/port pairs used to establish the initial connection to the Kafka cluster. Clients use this list to bootstrap and discover the full set of Kafka brokers. While the order of servers in the list does not matter, we recommend including more than one server to ensure resilience if any servers are down. This list does not need to contain the entire set of brokers, as Kafka clients automatically manage and update connections to the cluster efficiently. This list must be in the form <code>host1:port1,host2:port2,...</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_bootstrap.servers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "client.dns.lookup",
rust_field: "client_dns_lookup",
kafka_type: "string",
default: "ClientDnsLookup.USE_ALL_DNS_IPS.toString()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client uses DNS lookups. If set to <code>use_all_dns_ips</code>, connect to each returned IP address in sequence until a successful connection is established. After a disconnection, the next IP is used. Once all IPs have been used once, the client resolves the IP(s) from the hostname again (both the JVM and the OS cache DNS name lookups, however). If set to <code>resolve_canonical_bootstrap_servers_only</code>, resolve each bootstrap address into a list of canonical names. After the bootstrap phase, this behaves the same as <code>use_all_dns_ips</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_client.dns.lookup",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "group.id",
rust_field: "group_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A unique string that identifies the consumer group this consumer belongs to. This property is required if the consumer uses either the group management functionality by using <code>subscribe(topic)</code> or the Kafka-based offset management strategy.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_group.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "group.instance.id",
rust_field: "group_instance_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A unique identifier of the consumer instance provided by the end user. Only non-empty strings are permitted. If set, the consumer is treated as a static member, which means that only one instance with this ID is allowed in the consumer group at any time. This can be used in combination with a larger session timeout to avoid group rebalances caused by transient unavailability (e.g. process restarts). If not set, the consumer will join the group as a dynamic member, which is the traditional behavior.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_group.instance.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "session.timeout.ms",
rust_field: "session_timeout_ms",
kafka_type: "int",
default: "45000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The timeout used to detect client failures when using Kafka's group management facility. The client sends periodic heartbeats to indicate its liveness to the broker. If no heartbeats are received by the broker before the expiration of this session timeout, then the broker will remove this client from the group and initiate a rebalance. Note that the value must be in the allowable range as configured in the broker configuration by <code>group.min.session.timeout.ms</code> and <code>group.max.session.timeout.ms</code>. Note that this client configuration is not supported when <code>group.protocol</code> is set to \"consumer\". In that case, session timeout is controlled by the broker config <code>group.consumer.session.timeout.ms</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_session.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "heartbeat.interval.ms",
rust_field: "heartbeat_interval_ms",
kafka_type: "int",
default: "3000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The expected time between heartbeats to the consumer coordinator when using Kafka's group management facilities. Heartbeats are used to ensure that the consumer's session stays active and to facilitate rebalancing when new consumers join or leave the group. This config is only supported if <code>group.protocol</code> is set to \"classic\". In that case, the value must be set lower than <code>session.timeout.ms</code>, but typically should be set no higher than 1/3 of that value. It can be adjusted even lower to control the expected time for normal rebalances.If <code>group.protocol</code> is set to \"consumer\", this config is not supported, as the heartbeat interval is controlled by the broker with <code>group.consumer.heartbeat.interval.ms</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_heartbeat.interval.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "partition.assignment.strategy",
rust_field: "partition_assignment_strategy",
kafka_type: "list",
default: "List.of(RangeAssignor.class, CooperativeStickyAssignor.class)",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A list of class names or class types, ordered by preference, of supported partition assignment strategies that the client will use to distribute partition ownership amongst consumer instances when group management is used. Available options are:<ul><li><code>org.apache.kafka.clients.consumer.RangeAssignor</code>: Assigns partitions on a per-topic basis.</li><li><code>org.apache.kafka.clients.consumer.RoundRobinAssignor</code>: Assigns partitions to consumers in a round-robin fashion.</li><li><code>org.apache.kafka.clients.consumer.StickyAssignor</code>: Guarantees an assignment that is maximally balanced while preserving as many existing partition assignments as possible.</li><li><code>org.apache.kafka.clients.consumer.CooperativeStickyAssignor</code>: Follows the same StickyAssignor logic, but allows for cooperative rebalancing.</li></ul><p>The default assignor is [RangeAssignor, CooperativeStickyAssignor], which will use the RangeAssignor by default, but allows upgrading to the CooperativeStickyAssignor with just a single rolling bounce that removes the RangeAssignor from the list.</p><p>Implementing the <code>org.apache.kafka.clients.consumer.ConsumerPartitionAssignor</code> interface allows you to plug in a custom assignment strategy.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_partition.assignment.strategy",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metadata.max.age.ms",
rust_field: "metadata_max_age_ms",
kafka_type: "long",
default: "5 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metadata.max.age.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "enable.auto.commit",
rust_field: "enable_auto_commit",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If true the consumer's offset will be periodically committed in the background.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_enable.auto.commit",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "auto.commit.interval.ms",
rust_field: "auto_commit_interval_ms",
kafka_type: "int",
default: "5000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The frequency in milliseconds that the consumer offsets are auto-committed to Kafka if <code>enable.auto.commit</code> is set to <code>true</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_auto.commit.interval.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "client.id",
rust_field: "client_id",
kafka_type: "string",
default: "",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "An id string to pass to the server when making requests. The purpose of this is to be able to track the source of requests beyond just ip/port by allowing a logical application name to be included in server-side request logging.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "client.rack",
rust_field: "client_rack",
kafka_type: "string",
default: "DEFAULT_CLIENT_RACK",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A rack identifier for this client. This can be any string value which indicates where this client is physically located. It corresponds with the broker config 'broker.rack'",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_client.rack",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "max.partition.fetch.bytes",
rust_field: "max_partition_fetch_bytes",
kafka_type: "int",
default: "DEFAULT_MAX_PARTITION_FETCH_BYTES",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of data per-partition the server will return. Records are fetched in batches by the consumer. If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress. The maximum record batch size accepted by the broker is defined via <code>message.max.bytes</code> (broker config) or <code>max.message.bytes</code> (topic config). See fetch.max.bytes for limiting the consumer request size.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_max.partition.fetch.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "send.buffer.bytes",
rust_field: "send_buffer_bytes",
kafka_type: "int",
default: "128 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP send buffer (SO_SNDBUF) to use when sending data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_send.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "receive.buffer.bytes",
rust_field: "receive_buffer_bytes",
kafka_type: "int",
default: "64 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP receive buffer (SO_RCVBUF) to use when reading data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_receive.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "fetch.min.bytes",
rust_field: "fetch_min_bytes",
kafka_type: "int",
default: "DEFAULT_FETCH_MIN_BYTES",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The minimum amount of data the server should return for a fetch request. If insufficient data is available the request will wait for that much data to accumulate before answering the request. The default setting of 1 byte means that fetch requests are answered as soon as that many byte(s) of data is available or the fetch request times out waiting for data to arrive. Setting this to a larger value will cause the server to wait for larger amounts of data to accumulate which can improve server throughput a bit at the cost of some additional latency. Even if the total data available in the broker exceeds fetch.min.bytes, the actual returned size may still be less than this value due to per-partition limits max.partition.fetch.bytes and max returned limits fetch.max.bytes.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_fetch.min.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "fetch.max.bytes",
rust_field: "fetch_max_bytes",
kafka_type: "int",
default: "DEFAULT_FETCH_MAX_BYTES",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of data the server should return for a fetch request. Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum. The maximum record batch size accepted by the broker is defined via <code>message.max.bytes</code> (broker config) or <code>max.message.bytes</code> (topic config). A fetch request consists of many partitions, and there is another setting that controls how much data is returned for each partition in a fetch request - see <code>max.partition.fetch.bytes</code>. Note that the consumer performs multiple fetches in parallel.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_fetch.max.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "fetch.max.wait.ms",
rust_field: "fetch_max_wait_ms",
kafka_type: "int",
default: "DEFAULT_FETCH_MAX_WAIT_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time the server will block before answering the fetch request there isn't sufficient data to immediately satisfy the requirement given by fetch.min.bytes. This config is used only for local log fetch. To tune the remote fetch maximum wait time, please refer to 'remote.fetch.max.wait.ms' broker config",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_fetch.max.wait.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.ms",
rust_field: "reconnect_backoff_ms",
kafka_type: "long",
default: "50L",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The base amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all connection attempts by the client to a broker. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>reconnect.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_reconnect.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.max.ms",
rust_field: "reconnect_backoff_max_ms",
kafka_type: "long",
default: "1000L",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_reconnect.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.ms",
rust_field: "retry_backoff_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The amount of time to wait before attempting to retry a failed request to a given topic partition. This avoids repeatedly sending requests in a tight loop under some failure scenarios. This value is the initial backoff value and will increase exponentially for each failed request, up to the <code>retry.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.max.ms",
rust_field: "retry_backoff_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time in milliseconds to wait when retrying a request to the broker that has repeatedly failed. If provided, the backoff per client will increase exponentially for each failed request, up to this maximum. To prevent all clients from being synchronized upon retry, a randomized jitter with a factor of 0.2 will be applied to the backoff, resulting in the backoff falling within a range between 20% below and 20% above the computed value. If <code>retry.backoff.ms</code> is set to be higher than <code>retry.backoff.max.ms</code>, then <code>retry.backoff.max.ms</code> will be used as a constant backoff from the beginning without any exponential increase",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "enable.metrics.push",
rust_field: "enable_metrics_push",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Whether to enable pushing of client metrics to the cluster, if the cluster has a client metrics subscription which matches this client.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_enable.metrics.push",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "auto.offset.reset",
rust_field: "auto_offset_reset",
kafka_type: "string",
default: "AutoOffsetResetStrategy.LATEST.name()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server (e.g. because that data has been deleted): <ul><li>earliest: automatically reset the offset to the earliest offset</li><li>latest: automatically reset the offset to the latest offset</li><li>by_duration:<duration>: automatically reset the offset to a configured <duration> from the current timestamp. <duration> must be specified in ISO8601 format (PnDTnHnMn.nS). Negative duration is not allowed.</li><li>none: throw exception to the consumer if no previous offset is found for the consumer's group</li><li>anything else: throw exception to the consumer.</li></ul><p>Note that altering partition numbers while setting this config to latest may cause message delivery loss since producers could start to send messages to newly added partitions (i.e. no initial offsets exist yet) before consumers reset their offsets.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_auto.offset.reset",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "check.crcs",
rust_field: "check_crcs",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Automatically check the CRC32 of the records consumed. This ensures no on-the-wire or on-disk corruption to the messages occurred. This check adds some overhead, so it may be disabled in cases seeking extreme performance.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_check.crcs",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metrics.sample.window.ms",
rust_field: "metrics_sample_window_ms",
kafka_type: "long",
default: "30000",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The window of time a metrics sample is computed over.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metrics.sample.window.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metrics.num.samples",
rust_field: "metrics_num_samples",
kafka_type: "int",
default: "2",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The number of samples maintained to compute metrics.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metrics.num.samples",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metrics.recording.level",
rust_field: "metrics_recording_level",
kafka_type: "string",
default: "Sensor.RecordingLevel.INFO.toString()",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The highest recording level for metrics. It has three levels for recording metrics - info, debug, and trace.\n \nINFO level records only essential metrics necessary for monitoring system performance and health. It collects vital data without gathering too much detail, making it suitable for production environments where minimal overhead is desired.\n\nDEBUG level records most metrics, providing more detailed information about the system's operation. It's useful for development and testing environments where you need deeper insights to debug and fine-tune the application.\n\nTRACE level records all possible metrics, capturing every detail about the system's performance and operation. It's best for controlled environments where in-depth analysis is required, though it can introduce significant overhead.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metrics.recording.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metric.reporters",
rust_field: "metric_reporters",
kafka_type: "list",
default: "JmxReporter.class.getName()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of classes to use as metrics reporters. Implementing the <code>org.apache.kafka.common.metrics.MetricsReporter</code> interface allows plugging in classes that will be notified of new metric creation. When custom reporters are set and <code>org.apache.kafka.common.metrics.JmxReporter</code> is needed, it has to be explicitly added to the list.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metric.reporters",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "key.deserializer",
rust_field: "key_deserializer",
kafka_type: "class",
default: "(none)",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Deserializer class for key that implements the <code>org.apache.kafka.common.serialization.Deserializer</code> interface.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_key.deserializer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "value.deserializer",
rust_field: "value_deserializer",
kafka_type: "class",
default: "(none)",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Deserializer class for value that implements the <code>org.apache.kafka.common.serialization.Deserializer</code> interface.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_value.deserializer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "request.timeout.ms",
rust_field: "request_timeout_ms",
kafka_type: "int",
default: "30000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_request.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "default.api.timeout.ms",
rust_field: "default_api_timeout_ms",
kafka_type: "int",
default: "60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Specifies the timeout (in milliseconds) for client APIs. This configuration is used as the default timeout for all client operations that do not specify a <code>timeout</code> parameter.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_default.api.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.ms",
rust_field: "socket_connection_setup_timeout_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The amount of time the client will wait for the socket connection to be established. If the connection is not built before the timeout elapses, clients will close the socket channel. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>socket.connection.setup.timeout.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_socket.connection.setup.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.max.ms",
rust_field: "socket_connection_setup_timeout_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time the client will wait for the socket connection to be established. The connection setup timeout will increase exponentially for each consecutive connection failure up to this maximum. To avoid connection storms, a randomization factor of 0.2 will be applied to the timeout resulting in a random range between 20% below and 20% above the computed value.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_socket.connection.setup.timeout.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "connections.max.idle.ms",
rust_field: "connections_max_idle_ms",
kafka_type: "long",
default: "9 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Close idle connections after the number of milliseconds specified by this config.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_connections.max.idle.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "interceptor.classes",
rust_field: "interceptor_classes",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of classes to use as interceptors. Implementing the <code>org.apache.kafka.clients.consumer.ConsumerInterceptor</code> interface allows you to intercept (and possibly mutate) records received by the consumer. By default, there are no interceptors.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_interceptor.classes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "max.poll.records",
rust_field: "max_poll_records",
kafka_type: "int",
default: "DEFAULT_MAX_POLL_RECORDS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum number of records returned in a single call to poll(). Note, that <code>max.poll.records</code> does not impact the underlying fetching behavior. The consumer will cache the records from each fetch request and returns them incrementally from each poll.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_max.poll.records",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "max.poll.interval.ms",
rust_field: "max_poll_interval_ms",
kafka_type: "int",
default: "300000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum delay between invocations of poll() when using consumer group management. This places an upper bound on the amount of time that the consumer can be idle before fetching more records. If poll() is not called before expiration of this timeout, then the consumer is considered failed and the group will rebalance in order to reassign the partitions to another member. For consumers using a non-null <code>group.instance.id</code> which reach this timeout, partitions will not be immediately reassigned. Instead, the consumer will stop sending heartbeats and partitions will be reassigned after expiration of the session timeout (defined by the client config <code>session.timeout.ms</code> if using the Classic rebalance protocol, or by the broker config <code>group.consumer.session.timeout.ms</code> if using the Consumer protocol). This mirrors the behavior of a static consumer which has shutdown.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_max.poll.interval.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "exclude.internal.topics",
rust_field: "exclude_internal_topics",
kafka_type: "boolean",
default: "DEFAULT_EXCLUDE_INTERNAL_TOPICS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Whether internal topics matching a subscribed pattern should be excluded from the subscription. It is always possible to explicitly subscribe to an internal topic.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_exclude.internal.topics",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "isolation.level",
rust_field: "isolation_level",
kafka_type: "string",
default: "DEFAULT_ISOLATION_LEVEL",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how to read messages written transactionally. If set to <code>read_committed</code>, consumer.poll() will only return transactional messages which have been committed. If set to <code>read_uncommitted</code> (the default), consumer.poll() will return all messages, even transactional messages which have been aborted. Non-transactional messages will be returned unconditionally in either mode. <p>Messages will always be returned in offset order. Hence, in <code>read_committed</code> mode, consumer.poll() will only return messages up to the last stable offset (LSO), which is the one less than the offset of the first open transaction. In particular any messages appearing after messages belonging to ongoing transactions will be withheld until the relevant transaction has been completed. As a result, <code>read_committed</code> consumers will not be able to read up to the high watermark when there are in flight transactions.</p><p> Further, when in <code>read_committed</code> the seekToEnd method will return the LSO</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_isolation.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "allow.auto.create.topics",
rust_field: "allow_auto_create_topics",
kafka_type: "boolean",
default: "DEFAULT_ALLOW_AUTO_CREATE_TOPICS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Allow automatic topic creation on the broker when subscribing to or assigning a topic. A topic being subscribed to will be automatically created only if the broker allows for it using <code>auto.create.topics.enable</code> broker configuration.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_allow.auto.create.topics",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "group.protocol",
rust_field: "group_protocol",
kafka_type: "string",
default: "DEFAULT_GROUP_PROTOCOL",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The group protocol that the consumer uses. The supported values are <code>classic</code> or <code>consumer</code>. The default value is <code>classic</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_group.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "group.remote.assignor",
rust_field: "group_remote_assignor",
kafka_type: "string",
default: "DEFAULT_GROUP_REMOTE_ASSIGNOR",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The name of the server-side assignor to use. If not specified, the group coordinator will pick the first assignor defined in the broker config group.consumer.assignors.This configuration is applied only if <code>group.protocol</code> is set to \"consumer\".",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_group.remote.assignor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "security.providers",
rust_field: "security_providers",
kafka_type: "string",
default: "null",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of configurable creator classes each returning a provider implementing security algorithms. These classes should implement the <code>org.apache.kafka.common.security.auth.SecurityProviderCreator</code> interface.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_security.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "security.protocol",
rust_field: "security_protocol",
kafka_type: "string",
default: "CommonClientConfigs.DEFAULT_SECURITY_PROTOCOL",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "Protocol used to communicate with brokers.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_security.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.strategy",
rust_field: "metadata_recovery_strategy",
kafka_type: "string",
default: "CommonClientConfigs.DEFAULT_METADATA_RECOVERY_STRATEGY",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client recovers when none of the brokers known to it is available. If set to <code>none</code>, the client fails. If set to <code>rebootstrap</code>, the client repeats the bootstrap process using <code>bootstrap.servers</code>. Rebootstrapping is useful when a client communicates with brokers so infrequently that the set of brokers may change entirely before the client refreshes metadata. Metadata recovery is triggered when all last-known brokers appear unavailable simultaneously. Brokers appear unavailable when disconnected and no current retry attempt is in-progress. Consider increasing <code>reconnect.backoff.ms</code> and <code>reconnect.backoff.max.ms</code> and decreasing <code>socket.connection.setup.timeout.ms</code> and <code>socket.connection.setup.timeout.max.ms</code> for the client. Rebootstrap is also triggered if connection cannot be established to any of the brokers for <code>metadata.recovery.rebootstrap.trigger.ms</code> milliseconds or if server requests rebootstrap.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metadata.recovery.strategy",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.rebootstrap.trigger.ms",
rust_field: "metadata_recovery_rebootstrap_trigger_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_METADATA_RECOVERY_REBOOTSTRAP_TRIGGER_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If a client configured to rebootstrap using <code>metadata.recovery.strategy=rebootstrap</code> is unable to obtain metadata from any of the brokers in the last known metadata for this interval, client repeats the bootstrap process using <code>bootstrap.servers</code> configuration.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metadata.recovery.rebootstrap.trigger.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "share.acknowledgement.mode",
rust_field: "share_acknowledgement_mode",
kafka_type: "string",
default: "ShareAcknowledgementMode.IMPLICIT.name()",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "Controls the acknowledgement mode for a share consumer. If set to <code>implicit</code>, the acknowledgement mode of the consumer is implicit and it must not use <code>org.apache.kafka.clients.consumer.ShareConsumer.acknowledge()</code> to acknowledge delivery of records. Instead, delivery is acknowledged implicitly on the next call to poll or commit. If set to <code>explicit</code>, the acknowledgement mode of the consumer is explicit and it must use <code>org.apache.kafka.clients.consumer.ShareConsumer.acknowledge()</code> to acknowledge delivery of records.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_share.acknowledgement.mode",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "share.acquire.mode",
rust_field: "share_acquire_mode",
kafka_type: "string",
default: "DEFAULT_SHARE_ACQUIRE_MODE",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "Controls the acquire mode for a share consumer. If set to <code>record_limit</code>, the number of records returned in each poll() will not exceed the value of <code>max.poll.records</code>. If set to <code>batch_optimized</code>, the number of records returned in each poll() call may exceed <code>max.poll.records</code> to align with batch boundaries for optimization.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_share.acquire.mode",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "config.providers",
rust_field: "config_providers",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Comma-separated alias names for classes implementing the <code>ConfigProvider</code> interface. This enables loading configuration data (such as passwords, API keys, and other credentials) from external sources. For example, see <a href=\"https://kafka.apache.org/documentation/#config_providers\">Configuration Providers</a>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_config.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.protocol",
rust_field: "ssl_protocol",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_PROTOCOL",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SSL protocol used to generate the SSLContext. The default is 'TLSv1.3', which should be fine for most use cases. A typical alternative to the default is 'TLSv1.2'. Allowed values for this config are dependent on the JVM. Clients using the defaults for this config and 'ssl.enabled.protocols' will downgrade to 'TLSv1.2' if the server does not support 'TLSv1.3'. If this config is set to 'TLSv1.2', however, clients will not use 'TLSv1.3' even if it is one of the values in <code>ssl.enabled.protocols</code> and the server only supports 'TLSv1.3'.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.provider",
rust_field: "ssl_provider",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The name of the security provider used for SSL connections. Default value is the default security provider of the JVM.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.provider",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.cipher.suites",
rust_field: "ssl_cipher_suites",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "A list of cipher suites. This is a named combination of authentication, encryption, MAC and key exchange algorithm used to negotiate the security settings for a network connection using TLS or SSL network protocol. By default all the available cipher suites are supported.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.cipher.suites",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.enabled.protocols",
rust_field: "ssl_enabled_protocols",
kafka_type: "list",
default: "SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The list of protocols enabled for SSL connections. The default is 'TLSv1.2,TLSv1.3'. This means that clients and servers will prefer TLSv1.3 if both support it and fallback to TLSv1.2 otherwise (assuming both support at least TLSv1.2). This default should be fine for most use cases. If this configuration is set to an empty list, Kafka will use the protocols enabled by default in the underlying SSLEngine, which may include additional protocols depending on the JVM version. Also see the config documentation for <code>ssl.protocol</code> to understand how it can impact the TLS version negotiation behavior.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.enabled.protocols",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.type",
rust_field: "ssl_keystore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the key store file. This is optional for client. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keystore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.location",
rust_field: "ssl_keystore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the key store file. This is optional for client and can be used for two-way authentication for client.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keystore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.password",
rust_field: "ssl_keystore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The store password for the key store file. This is optional for client and only needed if 'ssl.keystore.location' is configured. Key store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keystore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.key.password",
rust_field: "ssl_key_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password of the private key in the key store file or the PEM key specified in 'ssl.keystore.key'.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.key.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.key",
rust_field: "ssl_keystore_key",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Private key in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with PKCS#8 keys. If the key is encrypted, key password must be specified using 'ssl.key.password'",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keystore.key",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.certificate.chain",
rust_field: "ssl_keystore_certificate_chain",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Certificate chain in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with a list of X.509 certificates",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keystore.certificate.chain",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.certificates",
rust_field: "ssl_truststore_certificates",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Trusted certificates in the format specified by 'ssl.truststore.type'. Default SSL engine factory supports only PEM format with X.509 certificates.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.truststore.certificates",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.type",
rust_field: "ssl_truststore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the trust store file. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.truststore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.location",
rust_field: "ssl_truststore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the trust store file.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.truststore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.password",
rust_field: "ssl_truststore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password for the trust store file. If a password is not set, trust store file configured will still be used, but integrity checking is disabled. Trust store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.truststore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keymanager.algorithm",
rust_field: "ssl_keymanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keymanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.trustmanager.algorithm",
rust_field: "ssl_trustmanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.trustmanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.endpoint.identification.algorithm",
rust_field: "ssl_endpoint_identification_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The endpoint identification algorithm to validate server hostname using server certificate. ",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.endpoint.identification.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.secure.random.implementation",
rust_field: "ssl_secure_random_implementation",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SecureRandom PRNG implementation to use for SSL cryptography operations. ",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.secure.random.implementation",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.engine.factory.class",
rust_field: "ssl_engine_factory_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The class of type org.apache.kafka.common.security.auth.SslEngineFactory to provide SSLEngine objects. Default value is org.apache.kafka.common.security.ssl.DefaultSslEngineFactory. Alternatively, setting this to org.apache.kafka.common.security.ssl.CommonNameLoggingSslEngineFactory will log the common name of expired SSL certificates used by clients to authenticate at any of the brokers with log level INFO. Note that this will cause a tiny delay during establishment of new connections from mTLS clients to brokers due to the extra code for examining the certificate chain provided by the client. Note further that the implementation uses a custom truststore based on the standard Java truststore and thus might be considered a security risk due to not being as mature as the standard one.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.engine.factory.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.service.name",
rust_field: "sasl_kerberos_service_name",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The Kerberos principal name that Kafka runs as. This can be defined either in Kafka's JAAS config or in Kafka's config.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.kerberos.service.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.kinit.cmd",
rust_field: "sasl_kerberos_kinit_cmd",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_KERBEROS_KINIT_CMD",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Kerberos kinit command path.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.kerberos.kinit.cmd",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.window.factor",
rust_field: "sasl_kerberos_ticket_renew_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread will sleep until the specified window factor of time from last refresh to ticket's expiry has been reached, at which time it will try to renew the ticket.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.kerberos.ticket.renew.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.jitter",
rust_field: "sasl_kerberos_ticket_renew_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Percentage of random jitter added to the renewal time.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.kerberos.ticket.renew.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.min.time.before.relogin",
rust_field: "sasl_kerberos_min_time_before_relogin",
kafka_type: "long",
default: "SaslConfigs.DEFAULT_KERBEROS_MIN_TIME_BEFORE_RELOGIN",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread sleep time between refresh attempts.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.kerberos.min.time.before.relogin",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.factor",
rust_field: "sasl_login_refresh_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login refresh thread will sleep until the specified window factor relative to the credential's lifetime has been reached, at which time it will try to refresh the credential. Legal values are between 0.5 (50%) and 1.0 (100%) inclusive; a default value of 0.8 (80%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.refresh.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.jitter",
rust_field: "sasl_login_refresh_window_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The maximum amount of random jitter relative to the credential's lifetime that is added to the login refresh thread's sleep time. Legal values are between 0 and 0.25 (25%) inclusive; a default value of 0.05 (5%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.refresh.window.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.min.period.seconds",
rust_field: "sasl_login_refresh_min_period_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_MIN_PERIOD_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The desired minimum time for the login refresh thread to wait before refreshing a credential, in seconds. Legal values are between 0 and 900 (15 minutes); a default value of 60 (1 minute) is used if no value is specified. This value and sasl.login.refresh.buffer.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.refresh.min.period.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.buffer.seconds",
rust_field: "sasl_login_refresh_buffer_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_BUFFER_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The amount of buffer time before credential expiration to maintain when refreshing a credential, in seconds. If a refresh would otherwise occur closer to expiration than the number of buffer seconds then the refresh will be moved up to maintain as much of the buffer time as possible. Legal values are between 0 and 3600 (1 hour); a default value of 300 (5 minutes) is used if no value is specified. This value and sasl.login.refresh.min.period.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.refresh.buffer.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.mechanism",
rust_field: "sasl_mechanism",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_SASL_MECHANISM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "SASL mechanism used for client connections. This may be any mechanism for which a security provider is available. GSSAPI is the default mechanism.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.mechanism",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.jaas.config",
rust_field: "sasl_jaas_config",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "JAAS login context parameters for SASL connections in the format used by JAAS configuration files. JAAS configuration file format is described <a href=\"https://docs.oracle.com/javase/8/docs/technotes/guides/security/jgss/tutorials/LoginConfigFile.html\">here</a>. The format for the value is: <code>loginModuleClass controlFlag (optionName=optionValue)*;</code>. For brokers, the config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.jaas.config=com.example.ScramLoginModule required;",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.jaas.config",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.client.callback.handler.class",
rust_field: "sasl_client_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL client callback handler class that implements the AuthenticateCallbackHandler interface.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.client.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.callback.handler.class",
rust_field: "sasl_login_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL login callback handler class that implements the AuthenticateCallbackHandler interface. For brokers, login callback handler config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.callback.handler.class=com.example.CustomScramLoginCallbackHandler",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.class",
rust_field: "sasl_login_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a class that implements the Login interface. For brokers, login config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.class=com.example.CustomScramLogin",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.connect.timeout.ms",
rust_field: "sasl_login_connect_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider connection timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.connect.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.read.timeout.ms",
rust_field: "sasl_login_read_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider read timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.read.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.max.ms",
rust_field: "sasl_login_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.ms",
rust_field: "sasl_login_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.retriever.class",
rust_field: "sasl_oauthbearer_jwt_retriever_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_RETRIEVER_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtRetriever</code> implementation used to request tokens from the identity provider.</p><p>The default configuration value represents a class that maintains backward compatibility with previous versions of Apache Kafka. The default implementation uses the configuration to determine which concrete implementation to create.<p>Other implementations that are provided include:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.ClientCredentialsJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.FileJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.JwtBearerJwtRetriever</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwt.retriever.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.validator.class",
rust_field: "sasl_oauthbearer_jwt_validator_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_VALIDATOR_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtValidator</code> implementation used to validate the JWT from the identity provider.</p><p>The default validator (<code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code>) maintains backward compatibility with previous versions of Apache Kafka. The default validator uses configuration to determine which concrete implementation to create.<p>The built-in <code>JwtValidator</code> implementations are:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.BrokerJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.ClientJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwt.validator.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope",
rust_field: "sasl_oauthbearer_scope",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This is the level of access a client application is granted to a resource or API which is included in the token request. If provided, it should match one or more scopes configured in the identity provider.</p><p>The scope was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>scope</code>. For backward compatibility, the <code>scope</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.scope</code> from configuration</li><li><code>scope</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.scope",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.id",
rust_field: "sasl_oauthbearer_client_credentials_client_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The ID (defined in/by the OAuth identity provider) to identify the client requesting the token.</p><p>The client ID was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientId</code>. For backward compatibility, the <code>clientId</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.id</code> from configuration</li><li><code>clientId</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.client.credentials.client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.secret",
rust_field: "sasl_oauthbearer_client_credentials_client_secret",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The secret (defined by either the user or preassigned, depending on the identity provider) of the client requesting the token.</p><p>The client secret was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientSecret</code>. For backward compatibility, the <code>clientSecret</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.secret</code> from configuration</li><li><code>clientSecret</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.client.credentials.client.secret",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.algorithm",
rust_field: "sasl_oauthbearer_assertion_algorithm",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The algorithm the Apache Kafka client should use to sign the assertion sent to the identity provider. It is also used as the value of the OAuth <code>alg</code> (Algorithm) header in the JWT assertion.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.aud",
rust_field: "sasl_oauthbearer_assertion_claim_aud",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The JWT <code>aud</code> (Audience) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.aud",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.exp.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_exp_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_EXP_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the future</em> for which the JWT is valid. The value is used to determine the JWT <code>exp</code> (Expiration) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>exp</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n exp = x + y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.exp.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.iss",
rust_field: "sasl_oauthbearer_assertion_claim_iss",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>iss</code> (Issuer) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.iss",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.jti.include",
rust_field: "sasl_oauthbearer_assertion_claim_jti_include",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_JTI_INCLUDE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>Flag that determines if the JWT assertion should generate a unique ID for the JWT and include it in the <code>jti</code> (JWT ID) claim.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.jti.include",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.nbf.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_nbf_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_NBF_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the past</em> from which the JWT is valid. The value is used to determine the JWT <code>nbf</code> (Not Before) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>nbf</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n nbf = x - y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.nbf.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.sub",
rust_field: "sasl_oauthbearer_assertion_claim_sub",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>sub</code> (Subject) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.sub",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.file",
rust_field: "sasl_oauthbearer_assertion_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a <em>pre-generated</em> JWT assertion.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect whenthe file changes to allow for the file to be reloaded on modifications. This allows for "live" assertion rotation without restarting the Kafka client.</p><p>The file contains the assertion in the serialized, three part JWT format:</p><ol><li>The <em>header</em> section is a base 64-encoded JWT header that contains values like <code>alg</code> (Algorithm), <code>typ</code> (Type, always the literal value <code>JWT</code>), etc.</li><li>The <em>payload</em> section includes the base 64-encoded set of JWT claims, such as <code>aud</code> (Audience), <code>iss</code> (Issuer), <code>sub</code> (Subject), etc.</li><li>The <em>signature</em> section is the concatenated <em>header</em> and <em>payload</em> sections that was signed using a private key</li></ol><p>See <a href=\"https://datatracker.ietf.org/doc/html/rfc7519\">RFC 7519</a> and <a href=\"https://datatracker.ietf.org/doc/html/rfc7515\">RFC 7515</a> for more details on the JWT and JWS formats.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, all other <code>sasl.oauthbearer.assertion.</code>* configurations are ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.file",
rust_field: "sasl_oauthbearer_assertion_private_key_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a private key in the standard PEM format which is used to sign the JWT assertion sent to the identity provider.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect when the file changes to allow for the file to be reloaded on modifications. This allows for "live" private key rotation without restarting the Kafka client.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.private.key.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.passphrase",
rust_field: "sasl_oauthbearer_assertion_private_key_passphrase",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The optional passphrase to decrypt the private key file specified by <code>sasl.oauthbearer.assertion.private.key.file</code>.</p><p><em>Note</em>: If the file referred to by <code>sasl.oauthbearer.assertion.private.key.file</code> is modified on the file system at runtime and it was created with a <em>different</em> passphrase than it was previously, the client will not be able to access the private key file because the passphrase is now out of date. For that reason, when using private key passphrases, either use the same passphrase each time, or—for improved security—restart the Kafka client using the new passphrase configuration.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.private.key.passphrase",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.template.file",
rust_field: "sasl_oauthbearer_assertion_template_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This optional configuration specifies the file containing the JWT headers and/or payload claims to be used when creating the JWT assertion.</p><p>Not all identity providers require the same set of claims; some may require a given claim while others may prohibit it. In order to provide the most flexibility, this configuration allows the user to provide the static header values and claims that are to be included in the JWT.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.template.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope.claim.name",
rust_field: "sasl_oauthbearer_scope_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SCOPE_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the scope is often named \"scope\", but this (optional) setting can provide a different name to use for the scope included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.scope.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.sub.claim.name",
rust_field: "sasl_oauthbearer_sub_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SUB_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the subject is often named \"sub\", but this (optional) setting can provide a different name to use for the subject included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.sub.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.token.endpoint.url",
rust_field: "sasl_oauthbearer_token_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The URL for the OAuth/OIDC identity provider. If the URL is HTTP(S)-based, it is the issuer's token endpoint URL to which requests will be made to login based on the configuration in <code>sasl.oauthbearer.jwt.retriever.class</code>. If the URL is file-based, it specifies a file containing an access token (in JWT serialized form) issued by the OAuth/OIDC identity provider to use for authorization.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.token.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.url",
rust_field: "sasl_oauthbearer_jwks_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth/OIDC provider URL from which the provider's <a href=\"https://datatracker.ietf.org/doc/html/rfc7517#section-5\">JWKS (JSON Web Key Set)</a> can be retrieved. The URL can be HTTP(S)-based or file-based. If the URL is HTTP(S)-based, the JWKS data will be retrieved from the OAuth/OIDC provider via the configured URL on broker startup. All then-current keys will be cached on the broker for incoming requests. If an authentication request is received for a JWT that includes a \"kid\" header claim value that isn't yet in the cache, the JWKS endpoint will be queried again on demand. However, the broker polls the URL every sasl.oauthbearer.jwks.endpoint.refresh.ms milliseconds to refresh the cache with any forthcoming keys before any JWT requests that include them are received. If the URL is file-based, the broker will load the JWKS file from a configured location on startup. In the event that the JWT includes a \"kid\" header value that isn't in the JWKS file, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwks.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.refresh.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_refresh_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the broker to wait between refreshing its JWKS (JSON Web Key Set) cache that contains the keys to verify the signature of the JWT.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwks.endpoint.refresh.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between attempts to retrieve the JWKS (JSON Web Key Set) from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between JWKS (JSON Web Key Set) retrieval attempts from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.clock.skew.seconds",
rust_field: "sasl_oauthbearer_clock_skew_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in seconds to allow for differences between the time of the OAuth/OIDC identity provider and the broker.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.clock.skew.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.audience",
rust_field: "sasl_oauthbearer_expected_audience",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. The JWT will be inspected for the standard OAuth \"aud\" claim and if this value is set, the broker will match the value from JWT's \"aud\" claim to see if there is an exact match. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.expected.audience",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.issuer",
rust_field: "sasl_oauthbearer_expected_issuer",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting for the broker to use to verify that the JWT was created by the expected issuer. The JWT will be inspected for the standard OAuth \"iss\" claim and if this value is set, the broker will match it exactly against what is in the JWT's \"iss\" claim. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.expected.issuer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.header.urlencode",
rust_field: "sasl_oauthbearer_header_urlencode",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_HEADER_URLENCODE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting to enable the OAuth client to URL-encode the client_id and client_secret in the authorization header in accordance with RFC6749, see <a href=\"https://datatracker.ietf.org/doc/html/rfc6749#section-2.3.1\">here</a> for more details. The default value is set to 'false' for backward compatibility",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.header.urlencode",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.nodelay",
rust_field: "socket_tcp_nodelay",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets TCP_NODELAY on broker TCP connections.",
source: "kacrab-runtime://config/socket.tcp.nodelay",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.quickack",
rust_field: "socket_tcp_quickack",
kafka_type: "boolean",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_QUICKACK after a broker TCP connection is established.",
source: "kacrab-runtime://config/socket.tcp.quickack",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.notsent.lowat.bytes",
rust_field: "socket_tcp_notsent_lowat_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android.",
documentation: "Sets TCP_NOTSENT_LOWAT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.notsent.lowat.bytes",
platforms: &["linux", "android"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.user.timeout.ms",
rust_field: "socket_tcp_user_timeout_ms",
kafka_type: "long",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_USER_TIMEOUT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.user.timeout.ms",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.congestion",
rust_field: "socket_tcp_congestion",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, freebsd.",
documentation: "Sets the TCP congestion-control algorithm on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.congestion",
platforms: &["linux", "freebsd"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.reuse.address",
rust_field: "socket_reuse_address",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets SO_REUSEADDR before connecting broker TCP sockets.",
source: "kacrab-runtime://config/socket.reuse.address",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.read.buffer.capacity.bytes",
rust_field: "socket_read_buffer_capacity_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime option generated from the runtime config overlay.",
documentation: "Initial reusable in-process read buffer capacity for broker frame reads.",
source: "kacrab-runtime://config/socket.read.buffer.capacity.bytes",
platforms: &[],
feature: None,
},
];
/// Kafka 4.3 admin configuration metadata plus Kacrab runtime overlays.
pub const ADMIN_CONFIGS: &[ConfigEntry] = &[
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "bootstrap.servers",
rust_field: "bootstrap_servers",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A list of host/port pairs used to establish the initial connection to the Kafka cluster. Clients use this list to bootstrap and discover the full set of Kafka brokers. While the order of servers in the list does not matter, we recommend including more than one server to ensure resilience if any servers are down. This list does not need to contain the entire set of brokers, as Kafka clients automatically manage and update connections to the cluster efficiently. This list must be in the form <code>host1:port1,host2:port2,...</code>.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_bootstrap.servers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "bootstrap.controllers",
rust_field: "bootstrap_controllers",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A list of host/port pairs to use for establishing the initial connection to the KRaft controller quorum. This list should be in the form <code>host1:port1,host2:port2,...</code>.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_bootstrap.controllers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "client.id",
rust_field: "client_id",
kafka_type: "string",
default: "",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "An id string to pass to the server when making requests. The purpose of this is to be able to track the source of requests beyond just ip/port by allowing a logical application name to be included in server-side request logging.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metadata.max.age.ms",
rust_field: "metadata_max_age_ms",
kafka_type: "long",
default: "5 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metadata.max.age.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "send.buffer.bytes",
rust_field: "send_buffer_bytes",
kafka_type: "int",
default: "128 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP send buffer (SO_SNDBUF) to use when sending data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_send.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "receive.buffer.bytes",
rust_field: "receive_buffer_bytes",
kafka_type: "int",
default: "64 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP receive buffer (SO_RCVBUF) to use when reading data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_receive.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.ms",
rust_field: "reconnect_backoff_ms",
kafka_type: "long",
default: "50L",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The base amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all connection attempts by the client to a broker. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>reconnect.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_reconnect.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.max.ms",
rust_field: "reconnect_backoff_max_ms",
kafka_type: "long",
default: "1000L",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_reconnect.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.ms",
rust_field: "retry_backoff_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MS",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The amount of time to wait before attempting to retry a failed request to a given topic partition. This avoids repeatedly sending requests in a tight loop under some failure scenarios. This value is the initial backoff value and will increase exponentially for each failed request, up to the <code>retry.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.max.ms",
rust_field: "retry_backoff_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The maximum amount of time in milliseconds to wait when retrying a request to the broker that has repeatedly failed. If provided, the backoff per client will increase exponentially for each failed request, up to this maximum. To prevent all clients from being synchronized upon retry, a randomized jitter with a factor of 0.2 will be applied to the backoff, resulting in the backoff falling within a range between 20% below and 20% above the computed value. If <code>retry.backoff.ms</code> is set to be higher than <code>retry.backoff.max.ms</code>, then <code>retry.backoff.max.ms</code> will be used as a constant backoff from the beginning without any exponential increase",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "enable.metrics.push",
rust_field: "enable_metrics_push",
kafka_type: "boolean",
default: "false",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Whether to enable pushing of client metrics to the cluster, if the cluster has a client metrics subscription which matches this client.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_enable.metrics.push",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "request.timeout.ms",
rust_field: "request_timeout_ms",
kafka_type: "int",
default: "30000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_request.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.ms",
rust_field: "socket_connection_setup_timeout_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The amount of time the client will wait for the socket connection to be established. If the connection is not built before the timeout elapses, clients will close the socket channel. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>socket.connection.setup.timeout.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_socket.connection.setup.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.max.ms",
rust_field: "socket_connection_setup_timeout_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time the client will wait for the socket connection to be established. The connection setup timeout will increase exponentially for each consecutive connection failure up to this maximum. To avoid connection storms, a randomization factor of 0.2 will be applied to the timeout resulting in a random range between 20% below and 20% above the computed value.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_socket.connection.setup.timeout.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "connections.max.idle.ms",
rust_field: "connections_max_idle_ms",
kafka_type: "long",
default: "5 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Close idle connections after the number of milliseconds specified by this config.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_connections.max.idle.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "retries",
rust_field: "retries",
kafka_type: "int",
default: "Integer.MAX_VALUE",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "It is recommended to set the value to either <code>MAX_VALUE</code> or zero, and use corresponding timeout parameters to control how long a client should retry a request. Setting a value greater than zero will cause the client to resend any request that fails with a potentially transient error. Setting a value of zero will lead to transient errors not being retried, and they will be propagated to the application to be handled.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_retries",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "default.api.timeout.ms",
rust_field: "default_api_timeout_ms",
kafka_type: "int",
default: "60000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Specifies the timeout (in milliseconds) for client APIs. This configuration is used as the default timeout for all client operations that do not specify a <code>timeout</code> parameter.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_default.api.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metrics.sample.window.ms",
rust_field: "metrics_sample_window_ms",
kafka_type: "long",
default: "30000",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The window of time a metrics sample is computed over.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metrics.sample.window.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metrics.num.samples",
rust_field: "metrics_num_samples",
kafka_type: "int",
default: "2",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The number of samples maintained to compute metrics.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metrics.num.samples",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metric.reporters",
rust_field: "metric_reporters",
kafka_type: "list",
default: "JmxReporter.class.getName()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of classes to use as metrics reporters. Implementing the <code>org.apache.kafka.common.metrics.MetricsReporter</code> interface allows plugging in classes that will be notified of new metric creation. When custom reporters are set and <code>org.apache.kafka.common.metrics.JmxReporter</code> is needed, it has to be explicitly added to the list.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metric.reporters",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metrics.recording.level",
rust_field: "metrics_recording_level",
kafka_type: "string",
default: "Sensor.RecordingLevel.INFO.toString()",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The highest recording level for metrics. It has three levels for recording metrics - info, debug, and trace.\n \nINFO level records only essential metrics necessary for monitoring system performance and health. It collects vital data without gathering too much detail, making it suitable for production environments where minimal overhead is desired.\n\nDEBUG level records most metrics, providing more detailed information about the system's operation. It's useful for development and testing environments where you need deeper insights to debug and fine-tune the application.\n\nTRACE level records all possible metrics, capturing every detail about the system's performance and operation. It's best for controlled environments where in-depth analysis is required, though it can introduce significant overhead.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metrics.recording.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "client.dns.lookup",
rust_field: "client_dns_lookup",
kafka_type: "string",
default: "ClientDnsLookup.USE_ALL_DNS_IPS.toString()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client uses DNS lookups. If set to <code>use_all_dns_ips</code>, connect to each returned IP address in sequence until a successful connection is established. After a disconnection, the next IP is used. Once all IPs have been used once, the client resolves the IP(s) from the hostname again (both the JVM and the OS cache DNS name lookups, however). If set to <code>resolve_canonical_bootstrap_servers_only</code>, resolve each bootstrap address into a list of canonical names. After the bootstrap phase, this behaves the same as <code>use_all_dns_ips</code>.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_client.dns.lookup",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "security.providers",
rust_field: "security_providers",
kafka_type: "string",
default: "null",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of configurable creator classes each returning a provider implementing security algorithms. These classes should implement the <code>org.apache.kafka.common.security.auth.SecurityProviderCreator</code> interface.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_security.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "security.protocol",
rust_field: "security_protocol",
kafka_type: "string",
default: "DEFAULT_SECURITY_PROTOCOL",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "Protocol used to communicate with brokers.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_security.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.strategy",
rust_field: "metadata_recovery_strategy",
kafka_type: "string",
default: "DEFAULT_METADATA_RECOVERY_STRATEGY",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client recovers when none of the brokers known to it is available. If set to <code>none</code>, the client fails. If set to <code>rebootstrap</code>, the client repeats the bootstrap process using <code>bootstrap.servers</code>. Rebootstrapping is useful when a client communicates with brokers so infrequently that the set of brokers may change entirely before the client refreshes metadata. Metadata recovery is triggered when all last-known brokers appear unavailable simultaneously. Brokers appear unavailable when disconnected and no current retry attempt is in-progress. Consider increasing <code>reconnect.backoff.ms</code> and <code>reconnect.backoff.max.ms</code> and decreasing <code>socket.connection.setup.timeout.ms</code> and <code>socket.connection.setup.timeout.max.ms</code> for the client. Rebootstrap is also triggered if connection cannot be established to any of the brokers for <code>metadata.recovery.rebootstrap.trigger.ms</code> milliseconds or if server requests rebootstrap.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metadata.recovery.strategy",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.rebootstrap.trigger.ms",
rust_field: "metadata_recovery_rebootstrap_trigger_ms",
kafka_type: "long",
default: "DEFAULT_METADATA_RECOVERY_REBOOTSTRAP_TRIGGER_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If a client configured to rebootstrap using <code>metadata.recovery.strategy=rebootstrap</code> is unable to obtain metadata from any of the brokers in the last known metadata for this interval, client repeats the bootstrap process using <code>bootstrap.servers</code> configuration.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metadata.recovery.rebootstrap.trigger.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "config.providers",
rust_field: "config_providers",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Comma-separated alias names for classes implementing the <code>ConfigProvider</code> interface. This enables loading configuration data (such as passwords, API keys, and other credentials) from external sources. For example, see <a href=\"https://kafka.apache.org/documentation/#config_providers\">Configuration Providers</a>.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_config.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.protocol",
rust_field: "ssl_protocol",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_PROTOCOL",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SSL protocol used to generate the SSLContext. The default is 'TLSv1.3', which should be fine for most use cases. A typical alternative to the default is 'TLSv1.2'. Allowed values for this config are dependent on the JVM. Clients using the defaults for this config and 'ssl.enabled.protocols' will downgrade to 'TLSv1.2' if the server does not support 'TLSv1.3'. If this config is set to 'TLSv1.2', however, clients will not use 'TLSv1.3' even if it is one of the values in <code>ssl.enabled.protocols</code> and the server only supports 'TLSv1.3'.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.provider",
rust_field: "ssl_provider",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The name of the security provider used for SSL connections. Default value is the default security provider of the JVM.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.provider",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.cipher.suites",
rust_field: "ssl_cipher_suites",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "A list of cipher suites. This is a named combination of authentication, encryption, MAC and key exchange algorithm used to negotiate the security settings for a network connection using TLS or SSL network protocol. By default all the available cipher suites are supported.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.cipher.suites",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.enabled.protocols",
rust_field: "ssl_enabled_protocols",
kafka_type: "list",
default: "SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The list of protocols enabled for SSL connections. The default is 'TLSv1.2,TLSv1.3'. This means that clients and servers will prefer TLSv1.3 if both support it and fallback to TLSv1.2 otherwise (assuming both support at least TLSv1.2). This default should be fine for most use cases. If this configuration is set to an empty list, Kafka will use the protocols enabled by default in the underlying SSLEngine, which may include additional protocols depending on the JVM version. Also see the config documentation for <code>ssl.protocol</code> to understand how it can impact the TLS version negotiation behavior.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.enabled.protocols",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.type",
rust_field: "ssl_keystore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the key store file. This is optional for client. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keystore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.location",
rust_field: "ssl_keystore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the key store file. This is optional for client and can be used for two-way authentication for client.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keystore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.password",
rust_field: "ssl_keystore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The store password for the key store file. This is optional for client and only needed if 'ssl.keystore.location' is configured. Key store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keystore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.key.password",
rust_field: "ssl_key_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password of the private key in the key store file or the PEM key specified in 'ssl.keystore.key'.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.key.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.key",
rust_field: "ssl_keystore_key",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Private key in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with PKCS#8 keys. If the key is encrypted, key password must be specified using 'ssl.key.password'",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keystore.key",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.certificate.chain",
rust_field: "ssl_keystore_certificate_chain",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Certificate chain in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with a list of X.509 certificates",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keystore.certificate.chain",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.certificates",
rust_field: "ssl_truststore_certificates",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Trusted certificates in the format specified by 'ssl.truststore.type'. Default SSL engine factory supports only PEM format with X.509 certificates.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.truststore.certificates",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.type",
rust_field: "ssl_truststore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the trust store file. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.truststore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.location",
rust_field: "ssl_truststore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the trust store file.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.truststore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.password",
rust_field: "ssl_truststore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password for the trust store file. If a password is not set, trust store file configured will still be used, but integrity checking is disabled. Trust store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.truststore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keymanager.algorithm",
rust_field: "ssl_keymanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keymanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.trustmanager.algorithm",
rust_field: "ssl_trustmanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.trustmanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.endpoint.identification.algorithm",
rust_field: "ssl_endpoint_identification_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The endpoint identification algorithm to validate server hostname using server certificate. ",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.endpoint.identification.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.secure.random.implementation",
rust_field: "ssl_secure_random_implementation",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SecureRandom PRNG implementation to use for SSL cryptography operations. ",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.secure.random.implementation",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.engine.factory.class",
rust_field: "ssl_engine_factory_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The class of type org.apache.kafka.common.security.auth.SslEngineFactory to provide SSLEngine objects. Default value is org.apache.kafka.common.security.ssl.DefaultSslEngineFactory. Alternatively, setting this to org.apache.kafka.common.security.ssl.CommonNameLoggingSslEngineFactory will log the common name of expired SSL certificates used by clients to authenticate at any of the brokers with log level INFO. Note that this will cause a tiny delay during establishment of new connections from mTLS clients to brokers due to the extra code for examining the certificate chain provided by the client. Note further that the implementation uses a custom truststore based on the standard Java truststore and thus might be considered a security risk due to not being as mature as the standard one.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.engine.factory.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.service.name",
rust_field: "sasl_kerberos_service_name",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The Kerberos principal name that Kafka runs as. This can be defined either in Kafka's JAAS config or in Kafka's config.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.kerberos.service.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.kinit.cmd",
rust_field: "sasl_kerberos_kinit_cmd",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_KERBEROS_KINIT_CMD",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Kerberos kinit command path.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.kerberos.kinit.cmd",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.window.factor",
rust_field: "sasl_kerberos_ticket_renew_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread will sleep until the specified window factor of time from last refresh to ticket's expiry has been reached, at which time it will try to renew the ticket.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.kerberos.ticket.renew.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.jitter",
rust_field: "sasl_kerberos_ticket_renew_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Percentage of random jitter added to the renewal time.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.kerberos.ticket.renew.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.min.time.before.relogin",
rust_field: "sasl_kerberos_min_time_before_relogin",
kafka_type: "long",
default: "SaslConfigs.DEFAULT_KERBEROS_MIN_TIME_BEFORE_RELOGIN",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread sleep time between refresh attempts.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.kerberos.min.time.before.relogin",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.factor",
rust_field: "sasl_login_refresh_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login refresh thread will sleep until the specified window factor relative to the credential's lifetime has been reached, at which time it will try to refresh the credential. Legal values are between 0.5 (50%) and 1.0 (100%) inclusive; a default value of 0.8 (80%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.refresh.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.jitter",
rust_field: "sasl_login_refresh_window_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The maximum amount of random jitter relative to the credential's lifetime that is added to the login refresh thread's sleep time. Legal values are between 0 and 0.25 (25%) inclusive; a default value of 0.05 (5%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.refresh.window.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.min.period.seconds",
rust_field: "sasl_login_refresh_min_period_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_MIN_PERIOD_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The desired minimum time for the login refresh thread to wait before refreshing a credential, in seconds. Legal values are between 0 and 900 (15 minutes); a default value of 60 (1 minute) is used if no value is specified. This value and sasl.login.refresh.buffer.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.refresh.min.period.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.buffer.seconds",
rust_field: "sasl_login_refresh_buffer_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_BUFFER_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The amount of buffer time before credential expiration to maintain when refreshing a credential, in seconds. If a refresh would otherwise occur closer to expiration than the number of buffer seconds then the refresh will be moved up to maintain as much of the buffer time as possible. Legal values are between 0 and 3600 (1 hour); a default value of 300 (5 minutes) is used if no value is specified. This value and sasl.login.refresh.min.period.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.refresh.buffer.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.mechanism",
rust_field: "sasl_mechanism",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_SASL_MECHANISM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "SASL mechanism used for client connections. This may be any mechanism for which a security provider is available. GSSAPI is the default mechanism.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.mechanism",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.jaas.config",
rust_field: "sasl_jaas_config",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "JAAS login context parameters for SASL connections in the format used by JAAS configuration files. JAAS configuration file format is described <a href=\"https://docs.oracle.com/javase/8/docs/technotes/guides/security/jgss/tutorials/LoginConfigFile.html\">here</a>. The format for the value is: <code>loginModuleClass controlFlag (optionName=optionValue)*;</code>. For brokers, the config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.jaas.config=com.example.ScramLoginModule required;",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.jaas.config",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.client.callback.handler.class",
rust_field: "sasl_client_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL client callback handler class that implements the AuthenticateCallbackHandler interface.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.client.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.callback.handler.class",
rust_field: "sasl_login_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL login callback handler class that implements the AuthenticateCallbackHandler interface. For brokers, login callback handler config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.callback.handler.class=com.example.CustomScramLoginCallbackHandler",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.class",
rust_field: "sasl_login_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a class that implements the Login interface. For brokers, login config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.class=com.example.CustomScramLogin",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.connect.timeout.ms",
rust_field: "sasl_login_connect_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider connection timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.connect.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.read.timeout.ms",
rust_field: "sasl_login_read_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider read timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.read.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.max.ms",
rust_field: "sasl_login_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.ms",
rust_field: "sasl_login_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.retriever.class",
rust_field: "sasl_oauthbearer_jwt_retriever_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_RETRIEVER_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtRetriever</code> implementation used to request tokens from the identity provider.</p><p>The default configuration value represents a class that maintains backward compatibility with previous versions of Apache Kafka. The default implementation uses the configuration to determine which concrete implementation to create.<p>Other implementations that are provided include:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.ClientCredentialsJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.FileJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.JwtBearerJwtRetriever</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwt.retriever.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.validator.class",
rust_field: "sasl_oauthbearer_jwt_validator_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_VALIDATOR_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtValidator</code> implementation used to validate the JWT from the identity provider.</p><p>The default validator (<code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code>) maintains backward compatibility with previous versions of Apache Kafka. The default validator uses configuration to determine which concrete implementation to create.<p>The built-in <code>JwtValidator</code> implementations are:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.BrokerJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.ClientJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwt.validator.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope",
rust_field: "sasl_oauthbearer_scope",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This is the level of access a client application is granted to a resource or API which is included in the token request. If provided, it should match one or more scopes configured in the identity provider.</p><p>The scope was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>scope</code>. For backward compatibility, the <code>scope</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.scope</code> from configuration</li><li><code>scope</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.scope",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.id",
rust_field: "sasl_oauthbearer_client_credentials_client_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The ID (defined in/by the OAuth identity provider) to identify the client requesting the token.</p><p>The client ID was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientId</code>. For backward compatibility, the <code>clientId</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.id</code> from configuration</li><li><code>clientId</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.client.credentials.client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.secret",
rust_field: "sasl_oauthbearer_client_credentials_client_secret",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The secret (defined by either the user or preassigned, depending on the identity provider) of the client requesting the token.</p><p>The client secret was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientSecret</code>. For backward compatibility, the <code>clientSecret</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.secret</code> from configuration</li><li><code>clientSecret</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.client.credentials.client.secret",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.algorithm",
rust_field: "sasl_oauthbearer_assertion_algorithm",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The algorithm the Apache Kafka client should use to sign the assertion sent to the identity provider. It is also used as the value of the OAuth <code>alg</code> (Algorithm) header in the JWT assertion.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.aud",
rust_field: "sasl_oauthbearer_assertion_claim_aud",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The JWT <code>aud</code> (Audience) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.aud",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.exp.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_exp_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_EXP_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the future</em> for which the JWT is valid. The value is used to determine the JWT <code>exp</code> (Expiration) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>exp</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n exp = x + y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.exp.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.iss",
rust_field: "sasl_oauthbearer_assertion_claim_iss",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>iss</code> (Issuer) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.iss",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.jti.include",
rust_field: "sasl_oauthbearer_assertion_claim_jti_include",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_JTI_INCLUDE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>Flag that determines if the JWT assertion should generate a unique ID for the JWT and include it in the <code>jti</code> (JWT ID) claim.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.jti.include",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.nbf.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_nbf_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_NBF_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the past</em> from which the JWT is valid. The value is used to determine the JWT <code>nbf</code> (Not Before) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>nbf</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n nbf = x - y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.nbf.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.sub",
rust_field: "sasl_oauthbearer_assertion_claim_sub",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>sub</code> (Subject) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.sub",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.file",
rust_field: "sasl_oauthbearer_assertion_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a <em>pre-generated</em> JWT assertion.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect whenthe file changes to allow for the file to be reloaded on modifications. This allows for "live" assertion rotation without restarting the Kafka client.</p><p>The file contains the assertion in the serialized, three part JWT format:</p><ol><li>The <em>header</em> section is a base 64-encoded JWT header that contains values like <code>alg</code> (Algorithm), <code>typ</code> (Type, always the literal value <code>JWT</code>), etc.</li><li>The <em>payload</em> section includes the base 64-encoded set of JWT claims, such as <code>aud</code> (Audience), <code>iss</code> (Issuer), <code>sub</code> (Subject), etc.</li><li>The <em>signature</em> section is the concatenated <em>header</em> and <em>payload</em> sections that was signed using a private key</li></ol><p>See <a href=\"https://datatracker.ietf.org/doc/html/rfc7519\">RFC 7519</a> and <a href=\"https://datatracker.ietf.org/doc/html/rfc7515\">RFC 7515</a> for more details on the JWT and JWS formats.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, all other <code>sasl.oauthbearer.assertion.</code>* configurations are ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.file",
rust_field: "sasl_oauthbearer_assertion_private_key_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a private key in the standard PEM format which is used to sign the JWT assertion sent to the identity provider.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect when the file changes to allow for the file to be reloaded on modifications. This allows for "live" private key rotation without restarting the Kafka client.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.private.key.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.passphrase",
rust_field: "sasl_oauthbearer_assertion_private_key_passphrase",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The optional passphrase to decrypt the private key file specified by <code>sasl.oauthbearer.assertion.private.key.file</code>.</p><p><em>Note</em>: If the file referred to by <code>sasl.oauthbearer.assertion.private.key.file</code> is modified on the file system at runtime and it was created with a <em>different</em> passphrase than it was previously, the client will not be able to access the private key file because the passphrase is now out of date. For that reason, when using private key passphrases, either use the same passphrase each time, or—for improved security—restart the Kafka client using the new passphrase configuration.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.private.key.passphrase",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.template.file",
rust_field: "sasl_oauthbearer_assertion_template_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This optional configuration specifies the file containing the JWT headers and/or payload claims to be used when creating the JWT assertion.</p><p>Not all identity providers require the same set of claims; some may require a given claim while others may prohibit it. In order to provide the most flexibility, this configuration allows the user to provide the static header values and claims that are to be included in the JWT.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.template.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope.claim.name",
rust_field: "sasl_oauthbearer_scope_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SCOPE_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the scope is often named \"scope\", but this (optional) setting can provide a different name to use for the scope included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.scope.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.sub.claim.name",
rust_field: "sasl_oauthbearer_sub_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SUB_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the subject is often named \"sub\", but this (optional) setting can provide a different name to use for the subject included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.sub.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.token.endpoint.url",
rust_field: "sasl_oauthbearer_token_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The URL for the OAuth/OIDC identity provider. If the URL is HTTP(S)-based, it is the issuer's token endpoint URL to which requests will be made to login based on the configuration in <code>sasl.oauthbearer.jwt.retriever.class</code>. If the URL is file-based, it specifies a file containing an access token (in JWT serialized form) issued by the OAuth/OIDC identity provider to use for authorization.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.token.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.url",
rust_field: "sasl_oauthbearer_jwks_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth/OIDC provider URL from which the provider's <a href=\"https://datatracker.ietf.org/doc/html/rfc7517#section-5\">JWKS (JSON Web Key Set)</a> can be retrieved. The URL can be HTTP(S)-based or file-based. If the URL is HTTP(S)-based, the JWKS data will be retrieved from the OAuth/OIDC provider via the configured URL on broker startup. All then-current keys will be cached on the broker for incoming requests. If an authentication request is received for a JWT that includes a \"kid\" header claim value that isn't yet in the cache, the JWKS endpoint will be queried again on demand. However, the broker polls the URL every sasl.oauthbearer.jwks.endpoint.refresh.ms milliseconds to refresh the cache with any forthcoming keys before any JWT requests that include them are received. If the URL is file-based, the broker will load the JWKS file from a configured location on startup. In the event that the JWT includes a \"kid\" header value that isn't in the JWKS file, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwks.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.refresh.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_refresh_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the broker to wait between refreshing its JWKS (JSON Web Key Set) cache that contains the keys to verify the signature of the JWT.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwks.endpoint.refresh.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between attempts to retrieve the JWKS (JSON Web Key Set) from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between JWKS (JSON Web Key Set) retrieval attempts from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.clock.skew.seconds",
rust_field: "sasl_oauthbearer_clock_skew_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in seconds to allow for differences between the time of the OAuth/OIDC identity provider and the broker.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.clock.skew.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.audience",
rust_field: "sasl_oauthbearer_expected_audience",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. The JWT will be inspected for the standard OAuth \"aud\" claim and if this value is set, the broker will match the value from JWT's \"aud\" claim to see if there is an exact match. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.expected.audience",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.issuer",
rust_field: "sasl_oauthbearer_expected_issuer",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting for the broker to use to verify that the JWT was created by the expected issuer. The JWT will be inspected for the standard OAuth \"iss\" claim and if this value is set, the broker will match it exactly against what is in the JWT's \"iss\" claim. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.expected.issuer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.header.urlencode",
rust_field: "sasl_oauthbearer_header_urlencode",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_HEADER_URLENCODE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting to enable the OAuth client to URL-encode the client_id and client_secret in the authorization header in accordance with RFC6749, see <a href=\"https://datatracker.ietf.org/doc/html/rfc6749#section-2.3.1\">here</a> for more details. The default value is set to 'false' for backward compatibility",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.header.urlencode",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.nodelay",
rust_field: "socket_tcp_nodelay",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets TCP_NODELAY on broker TCP connections.",
source: "kacrab-runtime://config/socket.tcp.nodelay",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.quickack",
rust_field: "socket_tcp_quickack",
kafka_type: "boolean",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_QUICKACK after a broker TCP connection is established.",
source: "kacrab-runtime://config/socket.tcp.quickack",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.notsent.lowat.bytes",
rust_field: "socket_tcp_notsent_lowat_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android.",
documentation: "Sets TCP_NOTSENT_LOWAT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.notsent.lowat.bytes",
platforms: &["linux", "android"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.user.timeout.ms",
rust_field: "socket_tcp_user_timeout_ms",
kafka_type: "long",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_USER_TIMEOUT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.user.timeout.ms",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.congestion",
rust_field: "socket_tcp_congestion",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, freebsd.",
documentation: "Sets the TCP congestion-control algorithm on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.congestion",
platforms: &["linux", "freebsd"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.reuse.address",
rust_field: "socket_reuse_address",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets SO_REUSEADDR before connecting broker TCP sockets.",
source: "kacrab-runtime://config/socket.reuse.address",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.read.buffer.capacity.bytes",
rust_field: "socket_read_buffer_capacity_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime option generated from the runtime config overlay.",
documentation: "Initial reusable in-process read buffer capacity for broker frame reads.",
source: "kacrab-runtime://config/socket.read.buffer.capacity.bytes",
platforms: &[],
feature: None,
},
];
/// Kafka 4.3 plus Kacrab runtime configuration metadata.
pub const CONFIG_CATALOG: &[ConfigEntry] = &[
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "bootstrap.servers",
rust_field: "bootstrap_servers",
kafka_type: "list",
default: "(none)",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A list of host/port pairs used to establish the initial connection to the Kafka cluster. Clients use this list to bootstrap and discover the full set of Kafka brokers. While the order of servers in the list does not matter, we recommend including more than one server to ensure resilience if any servers are down. This list does not need to contain the entire set of brokers, as Kafka clients automatically manage and update connections to the cluster efficiently. This list must be in the form <code>host1:port1,host2:port2,...</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_bootstrap.servers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "client.dns.lookup",
rust_field: "client_dns_lookup",
kafka_type: "string",
default: "ClientDnsLookup.USE_ALL_DNS_IPS.toString()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client uses DNS lookups. If set to <code>use_all_dns_ips</code>, connect to each returned IP address in sequence until a successful connection is established. After a disconnection, the next IP is used. Once all IPs have been used once, the client resolves the IP(s) from the hostname again (both the JVM and the OS cache DNS name lookups, however). If set to <code>resolve_canonical_bootstrap_servers_only</code>, resolve each bootstrap address into a list of canonical names. After the bootstrap phase, this behaves the same as <code>use_all_dns_ips</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_client.dns.lookup",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "buffer.memory",
rust_field: "buffer_memory",
kafka_type: "long",
default: "32 * 1024 * 1024L",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The total bytes of memory the producer can use to buffer records waiting to be sent to the server. If records are sent faster than they can be delivered to the server the producer will block for <code>max.block.ms</code> after which it will fail with an exception.<p>This setting should correspond roughly to the total memory the producer will use, but is not a hard bound since not all memory the producer uses is used for buffering. Some additional memory will be used for compression (if compression is enabled) as well as for maintaining in-flight requests.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_buffer.memory",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "retries",
rust_field: "retries",
kafka_type: "int",
default: "Integer.MAX_VALUE",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Number of times to retry a request that fails with a transient error. Setting a value greater than zero will cause the client to resend any record whose send fails with a potentially transient error. Requests will be retried this many times until they succeed, fail with a non-transient error, or the <code>delivery.timeout.ms</code> expires. Note that this automatic retry will simply resend the same record upon receiving the error. Setting a value of zero will disable this automatic retry behaviour, so that the transient errors will be propagated to the application to be handled. Users should generally prefer to leave this config unset and instead use <code>delivery.timeout.ms</code> to control retry behavior.<p>Enabling idempotence requires this config value to be greater than 0. If conflicting configurations are set and idempotence is not explicitly enabled, idempotence is disabled.<p>Allowing retries while setting <code>enable.idempotence</code> to <code>false</code> and <code>max.in.flight.requests.per.connection</code> to greater than 1 will potentially change the ordering of records because if two batches are sent to a single partition, and the first fails and is retried but the second succeeds, then the records in the second batch may appear first.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_retries",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "acks",
rust_field: "acks",
kafka_type: "string",
default: "all",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The number of acknowledgments the producer requires the leader to have received before considering a request complete. This controls the durability of records that are sent. The following settings are allowed: <ul> <li><code>acks=0</code> If set to zero then the producer will not wait for any acknowledgment from the server at all. The record will be immediately added to the socket buffer and considered sent. No guarantee can be made that the server has received the record in this case, and the <code>retries</code> configuration will not take effect (as the client won't generally know of any failures). The offset given back for each record will always be set to <code>-1</code>. <li><code>acks=1</code> This will mean the leader will write the record to its local log but will respond without awaiting full acknowledgement from all followers. In this case should the leader fail immediately after acknowledging the record but before the followers have replicated it then the record will be lost. <li><code>acks=all</code> This means the leader will wait for the full set of in-sync replicas to acknowledge the record. This guarantees that the record will not be lost as long as at least one in-sync replica remains alive. This is the strongest available guarantee. This is equivalent to the acks=-1 setting.</ul><p>Note that enabling idempotence requires this config value to be 'all'. If conflicting configurations are set and idempotence is not explicitly enabled, idempotence is disabled.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_acks",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "compression.type",
rust_field: "compression_type",
kafka_type: "string",
default: "CompressionType.NONE.name",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The compression type for all data generated by the producer. The default is none (i.e. no compression). Valid values are <code>none</code>, <code>gzip</code>, <code>snappy</code>, <code>lz4</code>, or <code>zstd</code>. Compression is of full batches of data, so the efficacy of batching will also impact the compression ratio (more batching means better compression).",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_compression.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "compression.gzip.level",
rust_field: "compression_gzip_level",
kafka_type: "int",
default: "CompressionType.GZIP.defaultLevel()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The compression level to use if compression.type is set to <code>gzip</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_compression.gzip.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "compression.lz4.level",
rust_field: "compression_lz4_level",
kafka_type: "int",
default: "CompressionType.LZ4.defaultLevel()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The compression level to use if compression.type is set to <code>lz4</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_compression.lz4.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "compression.zstd.level",
rust_field: "compression_zstd_level",
kafka_type: "int",
default: "CompressionType.ZSTD.defaultLevel()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The compression level to use if compression.type is set to <code>zstd</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_compression.zstd.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "batch.size",
rust_field: "batch_size",
kafka_type: "int",
default: "16384",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The producer will attempt to batch records together into fewer requests whenever multiple records are being sent to the same partition. This helps performance on both the client and the server. This configuration controls the default batch size in bytes. <p>No attempt will be made to batch records larger than this size. <p>Requests sent to brokers will contain multiple batches, one for each partition with data available to be sent. <p>A small batch size will make batching less common and may reduce throughput (a batch size of zero will disable batching entirely). A very large batch size may use memory a bit more wastefully as we will always allocate a buffer of the specified batch size in anticipation of additional records.<p>Note: This setting gives the upper bound of the batch size to be sent. If we have fewer than this many bytes accumulated for this partition, we will 'linger' for the <code>linger.ms</code> time waiting for more records to show up. This <code>linger.ms</code> setting defaults to 5, which means the producer will wait for 5ms or until the record batch is of <code>batch.size</code> (whichever happens first) before sending the record batch. Note that broker backpressure can result in a higher effective linger time than this setting. The default changed from 0 to 5 in Apache Kafka 4.0 as the efficiency gains from larger batches typically result in similar or lower producer latency despite the increased linger.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_batch.size",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "partitioner.adaptive.partitioning.enable",
rust_field: "partitioner_adaptive_partitioning_enable",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "When set to 'true', the producer will try to adapt to broker performance and produce more messages to partitions hosted on faster brokers. If 'false', the producer will try to distribute messages uniformly. Note: this setting has no effect if a custom partitioner is used.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_partitioner.adaptive.partitioning.enable",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "partitioner.availability.timeout.ms",
rust_field: "partitioner_availability_timeout_ms",
kafka_type: "long",
default: "0",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If a broker cannot process produce requests from a partition for <code>partitioner.availability.timeout.ms</code> time, the partitioner treats that partition as not available. If the value is 0, this logic is disabled. Note: this setting has no effect if a custom partitioner is used or <code>partitioner.adaptive.partitioning.enable</code> is set to 'false'.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_partitioner.availability.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "partitioner.ignore.keys",
rust_field: "partitioner_ignore_keys",
kafka_type: "boolean",
default: "false",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "When set to 'true' the producer won't use record keys to choose a partition. If 'false', producer would choose a partition based on a hash of the key when a key is present. Note: this setting has no effect if a custom partitioner is used.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_partitioner.ignore.keys",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "linger.ms",
rust_field: "linger_ms",
kafka_type: "long",
default: "5",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The producer groups together any records that arrive in between request transmissions into a single batched request. Normally this occurs only under load when records arrive faster than they can be sent out. However in some circumstances the client may want to reduce the number of requests even under moderate load. This setting accomplishes this by adding a small amount of artificial delay—that is, rather than immediately sending out a record, the producer will wait for up to the given delay to allow other records to be sent so that the sends can be batched together. This can be thought of as analogous to Nagle's algorithm in TCP. This setting gives the upper bound on the delay for batching: once we get <code>batch.size</code> worth of records for a partition it will be sent immediately regardless of this setting, however if we have fewer than this many bytes accumulated for this partition we will 'linger' for the specified time waiting for more records to show up. This setting defaults to 5 (i.e. 5ms delay). Increasing <code>linger.ms=50</code>, for example, would have the effect of reducing the number of requests sent but would add up to 50ms of latency to records sent in the absence of load.The default changed from 0 to 5 in Apache Kafka 4.0 as the efficiency gains from larger batches typically result in similar or lower producer latency despite the increased linger.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_linger.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "delivery.timeout.ms",
rust_field: "delivery_timeout_ms",
kafka_type: "int",
default: "120 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "An upper bound on the time to report success or failure after a call to <code>send()</code> returns. This limits the total time that a record will be delayed prior to sending, the time to await acknowledgement from the broker (if expected), and the time allowed for retriable send failures. The producer may report failure to send a record earlier than this config if either an unrecoverable error is encountered, the retries have been exhausted, or the record is added to a batch which reached an earlier delivery expiration deadline. The value of this config should be greater than or equal to the sum of <code>request.timeout.ms</code> and <code>linger.ms</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_delivery.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "client.id",
rust_field: "client_id",
kafka_type: "string",
default: "",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "An id string to pass to the server when making requests. The purpose of this is to be able to track the source of requests beyond just ip/port by allowing a logical application name to be included in server-side request logging.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "send.buffer.bytes",
rust_field: "send_buffer_bytes",
kafka_type: "int",
default: "128 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP send buffer (SO_SNDBUF) to use when sending data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_send.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "receive.buffer.bytes",
rust_field: "receive_buffer_bytes",
kafka_type: "int",
default: "32 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP receive buffer (SO_RCVBUF) to use when reading data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_receive.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "max.request.size",
rust_field: "max_request_size",
kafka_type: "int",
default: "1024 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum size of a request in bytes. This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. This is also effectively a cap on the maximum uncompressed record batch size. Note that the server has its own cap on the record batch size (after compression if compression is enabled) which may be different from this.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_max.request.size",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.ms",
rust_field: "reconnect_backoff_ms",
kafka_type: "long",
default: "50L",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The base amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all connection attempts by the client to a broker. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>reconnect.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_reconnect.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.max.ms",
rust_field: "reconnect_backoff_max_ms",
kafka_type: "long",
default: "1000L",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_reconnect.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.ms",
rust_field: "retry_backoff_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The amount of time to wait before attempting to retry a failed request to a given topic partition. This avoids repeatedly sending requests in a tight loop under some failure scenarios. This value is the initial backoff value and will increase exponentially for each failed request, up to the <code>retry.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.max.ms",
rust_field: "retry_backoff_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time in milliseconds to wait when retrying a request to the broker that has repeatedly failed. If provided, the backoff per client will increase exponentially for each failed request, up to this maximum. To prevent all clients from being synchronized upon retry, a randomized jitter with a factor of 0.2 will be applied to the backoff, resulting in the backoff falling within a range between 20% below and 20% above the computed value. If <code>retry.backoff.ms</code> is set to be higher than <code>retry.backoff.max.ms</code>, then <code>retry.backoff.max.ms</code> will be used as a constant backoff from the beginning without any exponential increase",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "enable.metrics.push",
rust_field: "enable_metrics_push",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Whether to enable pushing of client metrics to the cluster, if the cluster has a client metrics subscription which matches this client.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_enable.metrics.push",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "max.block.ms",
rust_field: "max_block_ms",
kafka_type: "long",
default: "60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The configuration controls how long the <code>KafkaProducer</code>'s <code>send()</code>, <code>partitionsFor()</code>, <code>initTransactions()</code>, <code>sendOffsetsToTransaction()</code>, <code>commitTransaction()</code> and <code>abortTransaction()</code> methods will block. For <code>send()</code> this timeout bounds the total time waiting for both metadata fetch and buffer allocation (blocking in the user-supplied serializers or partitioner is not counted against this timeout). For <code>partitionsFor()</code> this timeout bounds the time spent waiting for metadata if it is unavailable. The transaction-related methods always block, but may timeout if the transaction coordinator could not be discovered or did not respond within the timeout.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_max.block.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "request.timeout.ms",
rust_field: "request_timeout_ms",
kafka_type: "int",
default: "30 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted. This should be larger than <code>replica.lag.time.max.ms</code> (a broker configuration) to reduce the possibility of message duplication due to unnecessary producer retries.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_request.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metadata.max.age.ms",
rust_field: "metadata_max_age_ms",
kafka_type: "long",
default: "5 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metadata.max.age.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metadata.max.idle.ms",
rust_field: "metadata_max_idle_ms",
kafka_type: "long",
default: "5 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how long the producer will cache metadata for a topic that's idle. If the elapsed time since a topic was last produced to exceeds the metadata idle duration, then the topic's metadata is forgotten and the next access to it will force a metadata fetch request.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metadata.max.idle.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metrics.sample.window.ms",
rust_field: "metrics_sample_window_ms",
kafka_type: "long",
default: "30000",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The window of time a metrics sample is computed over.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metrics.sample.window.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metrics.num.samples",
rust_field: "metrics_num_samples",
kafka_type: "int",
default: "2",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The number of samples maintained to compute metrics.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metrics.num.samples",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metrics.recording.level",
rust_field: "metrics_recording_level",
kafka_type: "string",
default: "Sensor.RecordingLevel.INFO.toString()",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The highest recording level for metrics. It has three levels for recording metrics - info, debug, and trace.\n \nINFO level records only essential metrics necessary for monitoring system performance and health. It collects vital data without gathering too much detail, making it suitable for production environments where minimal overhead is desired.\n\nDEBUG level records most metrics, providing more detailed information about the system's operation. It's useful for development and testing environments where you need deeper insights to debug and fine-tune the application.\n\nTRACE level records all possible metrics, capturing every detail about the system's performance and operation. It's best for controlled environments where in-depth analysis is required, though it can introduce significant overhead.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metrics.recording.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metric.reporters",
rust_field: "metric_reporters",
kafka_type: "list",
default: "JmxReporter.class.getName()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of classes to use as metrics reporters. Implementing the <code>org.apache.kafka.common.metrics.MetricsReporter</code> interface allows plugging in classes that will be notified of new metric creation. When custom reporters are set and <code>org.apache.kafka.common.metrics.JmxReporter</code> is needed, it has to be explicitly added to the list.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metric.reporters",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "max.in.flight.requests.per.connection",
rust_field: "max_in_flight_requests_per_connection",
kafka_type: "int",
default: "5",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum number of unacknowledged requests the client will send on a single connection before blocking. Note that if this configuration is set to be greater than 1 and <code>enable.idempotence</code> is set to false, there is a risk of message reordering after a failed send due to retries (i.e., if retries are enabled); if retries are disabled or if <code>enable.idempotence</code> is set to true, ordering will be preserved. Additionally, enabling idempotence requires the value of this configuration to be less than or equal to 5, because broker only retains at most 5 batches for each producer. If the value is more than 5, previous batches may be removed on broker side.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_max.in.flight.requests.per.connection",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "key.serializer",
rust_field: "key_serializer",
kafka_type: "class",
default: "(none)",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Serializer class for key that implements the <code>org.apache.kafka.common.serialization.Serializer</code> interface.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_key.serializer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "value.serializer",
rust_field: "value_serializer",
kafka_type: "class",
default: "(none)",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Serializer class for value that implements the <code>org.apache.kafka.common.serialization.Serializer</code> interface.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_value.serializer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.ms",
rust_field: "socket_connection_setup_timeout_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The amount of time the client will wait for the socket connection to be established. If the connection is not built before the timeout elapses, clients will close the socket channel. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>socket.connection.setup.timeout.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_socket.connection.setup.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.max.ms",
rust_field: "socket_connection_setup_timeout_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time the client will wait for the socket connection to be established. The connection setup timeout will increase exponentially for each consecutive connection failure up to this maximum. To avoid connection storms, a randomization factor of 0.2 will be applied to the timeout resulting in a random range between 20% below and 20% above the computed value.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_socket.connection.setup.timeout.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "connections.max.idle.ms",
rust_field: "connections_max_idle_ms",
kafka_type: "long",
default: "9 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Close idle connections after the number of milliseconds specified by this config.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_connections.max.idle.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "partitioner.class",
rust_field: "partitioner_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Determines which partition to send a record to when records are produced. Available options are:<ul><li>If not set, the default partitioning logic is used. This strategy send records to a partition until at least batch.size bytes is produced to the partition. It works with the strategy:<ol><li>If no partition is specified but a key is present, choose a partition based on a hash of the key.</li><li>If no partition or key is present, choose the sticky partition that changes when at least batch.size bytes are produced to the partition.</li></ol></li><li><code>org.apache.kafka.clients.producer.RoundRobinPartitioner</code>: A partitioning strategy where each record in a series of consecutive records is sent to a different partition, regardless of whether the 'key' is provided or not, until partitions run out and the process starts over again. Note: There's a known issue that will cause uneven distribution when a new batch is created. See KAFKA-9965 for more detail.</li></ul><p>Implementing the <code>org.apache.kafka.clients.producer.Partitioner</code> interface allows you to plug in a custom partitioner.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_partitioner.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "interceptor.classes",
rust_field: "interceptor_classes",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of classes to use as interceptors. Implementing the <code>org.apache.kafka.clients.producer.ProducerInterceptor</code> interface allows you to intercept (and possibly mutate) the records received by the producer before they are published to the Kafka cluster. By default, there are no interceptors.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_interceptor.classes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "security.protocol",
rust_field: "security_protocol",
kafka_type: "string",
default: "CommonClientConfigs.DEFAULT_SECURITY_PROTOCOL",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "Protocol used to communicate with brokers.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_security.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "security.providers",
rust_field: "security_providers",
kafka_type: "string",
default: "null",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of configurable creator classes each returning a provider implementing security algorithms. These classes should implement the <code>org.apache.kafka.common.security.auth.SecurityProviderCreator</code> interface.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_security.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "enable.idempotence",
rust_field: "enable_idempotence",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "When set to 'true', the producer will ensure that exactly one copy of each message is written in the stream. If 'false', producer retries due to broker failures, etc., may write duplicates of the retried message in the stream. Note that enabling idempotence requires <code>max.in.flight.requests.per.connection</code> to be less than or equal to 5 (with message ordering preserved for any allowable value), <code>retries</code> to be greater than 0, and <code>acks</code> must be 'all'. <p>Idempotence is enabled by default if no conflicting configurations are set. If conflicting configurations are set and idempotence is not explicitly enabled, idempotence is disabled. If idempotence is explicitly enabled and conflicting configurations are set, a <code>ConfigException</code> is thrown.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_enable.idempotence",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "transaction.timeout.ms",
rust_field: "transaction_timeout_ms",
kafka_type: "int",
default: "60000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time in milliseconds that a transaction will remain open before the coordinator proactively aborts it. The start of the transaction is set at the time that the first partition is added to it. If this value is larger than the <code>transaction.max.timeout.ms</code> setting in the broker, the request will fail with a <code>InvalidTxnTimeoutException</code> error.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_transaction.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "transactional.id",
rust_field: "transactional_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The TransactionalId to use for transactional delivery. This enables reliability semantics which span multiple producer sessions since it allows the client to guarantee that transactions using the same TransactionalId have been completed prior to starting any new transactions. If no TransactionalId is provided, then the producer is limited to idempotent delivery. If a TransactionalId is configured, <code>enable.idempotence</code> is implied. By default the TransactionId is not configured, which means transactions cannot be used. Note that, by default, transactions require a cluster of at least three brokers which is the recommended setting for production; for development you can change this, by adjusting broker setting <code>transaction.state.log.replication.factor</code>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_transactional.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "transaction.two.phase.commit.enable",
rust_field: "transaction_two_phase_commit_enable",
kafka_type: "boolean",
default: "false",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If set to true, then the broker is informed that the client is participating in two phase commit protocol and transactions that this client starts never expire.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_transaction.two.phase.commit.enable",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.strategy",
rust_field: "metadata_recovery_strategy",
kafka_type: "string",
default: "CommonClientConfigs.DEFAULT_METADATA_RECOVERY_STRATEGY",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client recovers when none of the brokers known to it is available. If set to <code>none</code>, the client fails. If set to <code>rebootstrap</code>, the client repeats the bootstrap process using <code>bootstrap.servers</code>. Rebootstrapping is useful when a client communicates with brokers so infrequently that the set of brokers may change entirely before the client refreshes metadata. Metadata recovery is triggered when all last-known brokers appear unavailable simultaneously. Brokers appear unavailable when disconnected and no current retry attempt is in-progress. Consider increasing <code>reconnect.backoff.ms</code> and <code>reconnect.backoff.max.ms</code> and decreasing <code>socket.connection.setup.timeout.ms</code> and <code>socket.connection.setup.timeout.max.ms</code> for the client. Rebootstrap is also triggered if connection cannot be established to any of the brokers for <code>metadata.recovery.rebootstrap.trigger.ms</code> milliseconds or if server requests rebootstrap.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metadata.recovery.strategy",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.rebootstrap.trigger.ms",
rust_field: "metadata_recovery_rebootstrap_trigger_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_METADATA_RECOVERY_REBOOTSTRAP_TRIGGER_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If a client configured to rebootstrap using <code>metadata.recovery.strategy=rebootstrap</code> is unable to obtain metadata from any of the brokers in the last known metadata for this interval, client repeats the bootstrap process using <code>bootstrap.servers</code> configuration.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_metadata.recovery.rebootstrap.trigger.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "config.providers",
rust_field: "config_providers",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Comma-separated alias names for classes implementing the <code>ConfigProvider</code> interface. This enables loading configuration data (such as passwords, API keys, and other credentials) from external sources. For example, see <a href=\"https://kafka.apache.org/documentation/#config_providers\">Configuration Providers</a>.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_config.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.protocol",
rust_field: "ssl_protocol",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_PROTOCOL",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SSL protocol used to generate the SSLContext. The default is 'TLSv1.3', which should be fine for most use cases. A typical alternative to the default is 'TLSv1.2'. Allowed values for this config are dependent on the JVM. Clients using the defaults for this config and 'ssl.enabled.protocols' will downgrade to 'TLSv1.2' if the server does not support 'TLSv1.3'. If this config is set to 'TLSv1.2', however, clients will not use 'TLSv1.3' even if it is one of the values in <code>ssl.enabled.protocols</code> and the server only supports 'TLSv1.3'.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.provider",
rust_field: "ssl_provider",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The name of the security provider used for SSL connections. Default value is the default security provider of the JVM.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.provider",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.cipher.suites",
rust_field: "ssl_cipher_suites",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "A list of cipher suites. This is a named combination of authentication, encryption, MAC and key exchange algorithm used to negotiate the security settings for a network connection using TLS or SSL network protocol. By default all the available cipher suites are supported.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.cipher.suites",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.enabled.protocols",
rust_field: "ssl_enabled_protocols",
kafka_type: "list",
default: "SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The list of protocols enabled for SSL connections. The default is 'TLSv1.2,TLSv1.3'. This means that clients and servers will prefer TLSv1.3 if both support it and fallback to TLSv1.2 otherwise (assuming both support at least TLSv1.2). This default should be fine for most use cases. If this configuration is set to an empty list, Kafka will use the protocols enabled by default in the underlying SSLEngine, which may include additional protocols depending on the JVM version. Also see the config documentation for <code>ssl.protocol</code> to understand how it can impact the TLS version negotiation behavior.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.enabled.protocols",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.type",
rust_field: "ssl_keystore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the key store file. This is optional for client. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keystore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.location",
rust_field: "ssl_keystore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the key store file. This is optional for client and can be used for two-way authentication for client.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keystore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.password",
rust_field: "ssl_keystore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The store password for the key store file. This is optional for client and only needed if 'ssl.keystore.location' is configured. Key store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keystore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.key.password",
rust_field: "ssl_key_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password of the private key in the key store file or the PEM key specified in 'ssl.keystore.key'.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.key.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.key",
rust_field: "ssl_keystore_key",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Private key in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with PKCS#8 keys. If the key is encrypted, key password must be specified using 'ssl.key.password'",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keystore.key",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.certificate.chain",
rust_field: "ssl_keystore_certificate_chain",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Certificate chain in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with a list of X.509 certificates",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keystore.certificate.chain",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.certificates",
rust_field: "ssl_truststore_certificates",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Trusted certificates in the format specified by 'ssl.truststore.type'. Default SSL engine factory supports only PEM format with X.509 certificates.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.truststore.certificates",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.type",
rust_field: "ssl_truststore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the trust store file. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.truststore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.location",
rust_field: "ssl_truststore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the trust store file.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.truststore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.password",
rust_field: "ssl_truststore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password for the trust store file. If a password is not set, trust store file configured will still be used, but integrity checking is disabled. Trust store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.truststore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.keymanager.algorithm",
rust_field: "ssl_keymanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.keymanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.trustmanager.algorithm",
rust_field: "ssl_trustmanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.trustmanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.endpoint.identification.algorithm",
rust_field: "ssl_endpoint_identification_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The endpoint identification algorithm to validate server hostname using server certificate. ",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.endpoint.identification.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.secure.random.implementation",
rust_field: "ssl_secure_random_implementation",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SecureRandom PRNG implementation to use for SSL cryptography operations. ",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.secure.random.implementation",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "ssl.engine.factory.class",
rust_field: "ssl_engine_factory_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The class of type org.apache.kafka.common.security.auth.SslEngineFactory to provide SSLEngine objects. Default value is org.apache.kafka.common.security.ssl.DefaultSslEngineFactory. Alternatively, setting this to org.apache.kafka.common.security.ssl.CommonNameLoggingSslEngineFactory will log the common name of expired SSL certificates used by clients to authenticate at any of the brokers with log level INFO. Note that this will cause a tiny delay during establishment of new connections from mTLS clients to brokers due to the extra code for examining the certificate chain provided by the client. Note further that the implementation uses a custom truststore based on the standard Java truststore and thus might be considered a security risk due to not being as mature as the standard one.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_ssl.engine.factory.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.service.name",
rust_field: "sasl_kerberos_service_name",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The Kerberos principal name that Kafka runs as. This can be defined either in Kafka's JAAS config or in Kafka's config.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.kerberos.service.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.kinit.cmd",
rust_field: "sasl_kerberos_kinit_cmd",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_KERBEROS_KINIT_CMD",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Kerberos kinit command path.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.kerberos.kinit.cmd",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.window.factor",
rust_field: "sasl_kerberos_ticket_renew_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread will sleep until the specified window factor of time from last refresh to ticket's expiry has been reached, at which time it will try to renew the ticket.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.kerberos.ticket.renew.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.jitter",
rust_field: "sasl_kerberos_ticket_renew_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Percentage of random jitter added to the renewal time.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.kerberos.ticket.renew.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.min.time.before.relogin",
rust_field: "sasl_kerberos_min_time_before_relogin",
kafka_type: "long",
default: "SaslConfigs.DEFAULT_KERBEROS_MIN_TIME_BEFORE_RELOGIN",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread sleep time between refresh attempts.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.kerberos.min.time.before.relogin",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.factor",
rust_field: "sasl_login_refresh_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login refresh thread will sleep until the specified window factor relative to the credential's lifetime has been reached, at which time it will try to refresh the credential. Legal values are between 0.5 (50%) and 1.0 (100%) inclusive; a default value of 0.8 (80%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.refresh.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.jitter",
rust_field: "sasl_login_refresh_window_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The maximum amount of random jitter relative to the credential's lifetime that is added to the login refresh thread's sleep time. Legal values are between 0 and 0.25 (25%) inclusive; a default value of 0.05 (5%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.refresh.window.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.min.period.seconds",
rust_field: "sasl_login_refresh_min_period_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_MIN_PERIOD_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The desired minimum time for the login refresh thread to wait before refreshing a credential, in seconds. Legal values are between 0 and 900 (15 minutes); a default value of 60 (1 minute) is used if no value is specified. This value and sasl.login.refresh.buffer.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.refresh.min.period.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.buffer.seconds",
rust_field: "sasl_login_refresh_buffer_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_BUFFER_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The amount of buffer time before credential expiration to maintain when refreshing a credential, in seconds. If a refresh would otherwise occur closer to expiration than the number of buffer seconds then the refresh will be moved up to maintain as much of the buffer time as possible. Legal values are between 0 and 3600 (1 hour); a default value of 300 (5 minutes) is used if no value is specified. This value and sasl.login.refresh.min.period.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.refresh.buffer.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.mechanism",
rust_field: "sasl_mechanism",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_SASL_MECHANISM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "SASL mechanism used for client connections. This may be any mechanism for which a security provider is available. GSSAPI is the default mechanism.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.mechanism",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.jaas.config",
rust_field: "sasl_jaas_config",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "JAAS login context parameters for SASL connections in the format used by JAAS configuration files. JAAS configuration file format is described <a href=\"https://docs.oracle.com/javase/8/docs/technotes/guides/security/jgss/tutorials/LoginConfigFile.html\">here</a>. The format for the value is: <code>loginModuleClass controlFlag (optionName=optionValue)*;</code>. For brokers, the config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.jaas.config=com.example.ScramLoginModule required;",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.jaas.config",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.client.callback.handler.class",
rust_field: "sasl_client_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL client callback handler class that implements the AuthenticateCallbackHandler interface.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.client.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.callback.handler.class",
rust_field: "sasl_login_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL login callback handler class that implements the AuthenticateCallbackHandler interface. For brokers, login callback handler config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.callback.handler.class=com.example.CustomScramLoginCallbackHandler",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.class",
rust_field: "sasl_login_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a class that implements the Login interface. For brokers, login config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.class=com.example.CustomScramLogin",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.connect.timeout.ms",
rust_field: "sasl_login_connect_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider connection timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.connect.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.read.timeout.ms",
rust_field: "sasl_login_read_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider read timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.read.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.max.ms",
rust_field: "sasl_login_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.ms",
rust_field: "sasl_login_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.login.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.retriever.class",
rust_field: "sasl_oauthbearer_jwt_retriever_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_RETRIEVER_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtRetriever</code> implementation used to request tokens from the identity provider.</p><p>The default configuration value represents a class that maintains backward compatibility with previous versions of Apache Kafka. The default implementation uses the configuration to determine which concrete implementation to create.<p>Other implementations that are provided include:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.ClientCredentialsJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.FileJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.JwtBearerJwtRetriever</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwt.retriever.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.validator.class",
rust_field: "sasl_oauthbearer_jwt_validator_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_VALIDATOR_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtValidator</code> implementation used to validate the JWT from the identity provider.</p><p>The default validator (<code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code>) maintains backward compatibility with previous versions of Apache Kafka. The default validator uses configuration to determine which concrete implementation to create.<p>The built-in <code>JwtValidator</code> implementations are:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.BrokerJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.ClientJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwt.validator.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope",
rust_field: "sasl_oauthbearer_scope",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This is the level of access a client application is granted to a resource or API which is included in the token request. If provided, it should match one or more scopes configured in the identity provider.</p><p>The scope was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>scope</code>. For backward compatibility, the <code>scope</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.scope</code> from configuration</li><li><code>scope</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.scope",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.id",
rust_field: "sasl_oauthbearer_client_credentials_client_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The ID (defined in/by the OAuth identity provider) to identify the client requesting the token.</p><p>The client ID was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientId</code>. For backward compatibility, the <code>clientId</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.id</code> from configuration</li><li><code>clientId</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.client.credentials.client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.secret",
rust_field: "sasl_oauthbearer_client_credentials_client_secret",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The secret (defined by either the user or preassigned, depending on the identity provider) of the client requesting the token.</p><p>The client secret was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientSecret</code>. For backward compatibility, the <code>clientSecret</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.secret</code> from configuration</li><li><code>clientSecret</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.client.credentials.client.secret",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.algorithm",
rust_field: "sasl_oauthbearer_assertion_algorithm",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The algorithm the Apache Kafka client should use to sign the assertion sent to the identity provider. It is also used as the value of the OAuth <code>alg</code> (Algorithm) header in the JWT assertion.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.aud",
rust_field: "sasl_oauthbearer_assertion_claim_aud",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The JWT <code>aud</code> (Audience) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.aud",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.exp.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_exp_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_EXP_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the future</em> for which the JWT is valid. The value is used to determine the JWT <code>exp</code> (Expiration) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>exp</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n exp = x + y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.exp.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.iss",
rust_field: "sasl_oauthbearer_assertion_claim_iss",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>iss</code> (Issuer) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.iss",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.jti.include",
rust_field: "sasl_oauthbearer_assertion_claim_jti_include",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_JTI_INCLUDE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>Flag that determines if the JWT assertion should generate a unique ID for the JWT and include it in the <code>jti</code> (JWT ID) claim.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.jti.include",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.nbf.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_nbf_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_NBF_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the past</em> from which the JWT is valid. The value is used to determine the JWT <code>nbf</code> (Not Before) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>nbf</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n nbf = x - y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.nbf.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.sub",
rust_field: "sasl_oauthbearer_assertion_claim_sub",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>sub</code> (Subject) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.claim.sub",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.file",
rust_field: "sasl_oauthbearer_assertion_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a <em>pre-generated</em> JWT assertion.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect whenthe file changes to allow for the file to be reloaded on modifications. This allows for "live" assertion rotation without restarting the Kafka client.</p><p>The file contains the assertion in the serialized, three part JWT format:</p><ol><li>The <em>header</em> section is a base 64-encoded JWT header that contains values like <code>alg</code> (Algorithm), <code>typ</code> (Type, always the literal value <code>JWT</code>), etc.</li><li>The <em>payload</em> section includes the base 64-encoded set of JWT claims, such as <code>aud</code> (Audience), <code>iss</code> (Issuer), <code>sub</code> (Subject), etc.</li><li>The <em>signature</em> section is the concatenated <em>header</em> and <em>payload</em> sections that was signed using a private key</li></ol><p>See <a href=\"https://datatracker.ietf.org/doc/html/rfc7519\">RFC 7519</a> and <a href=\"https://datatracker.ietf.org/doc/html/rfc7515\">RFC 7515</a> for more details on the JWT and JWS formats.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, all other <code>sasl.oauthbearer.assertion.</code>* configurations are ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.file",
rust_field: "sasl_oauthbearer_assertion_private_key_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a private key in the standard PEM format which is used to sign the JWT assertion sent to the identity provider.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect when the file changes to allow for the file to be reloaded on modifications. This allows for "live" private key rotation without restarting the Kafka client.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.private.key.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.passphrase",
rust_field: "sasl_oauthbearer_assertion_private_key_passphrase",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The optional passphrase to decrypt the private key file specified by <code>sasl.oauthbearer.assertion.private.key.file</code>.</p><p><em>Note</em>: If the file referred to by <code>sasl.oauthbearer.assertion.private.key.file</code> is modified on the file system at runtime and it was created with a <em>different</em> passphrase than it was previously, the client will not be able to access the private key file because the passphrase is now out of date. For that reason, when using private key passphrases, either use the same passphrase each time, or—for improved security—restart the Kafka client using the new passphrase configuration.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.private.key.passphrase",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.template.file",
rust_field: "sasl_oauthbearer_assertion_template_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This optional configuration specifies the file containing the JWT headers and/or payload claims to be used when creating the JWT assertion.</p><p>Not all identity providers require the same set of claims; some may require a given claim while others may prohibit it. In order to provide the most flexibility, this configuration allows the user to provide the static header values and claims that are to be included in the JWT.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.assertion.template.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope.claim.name",
rust_field: "sasl_oauthbearer_scope_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SCOPE_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the scope is often named \"scope\", but this (optional) setting can provide a different name to use for the scope included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.scope.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.sub.claim.name",
rust_field: "sasl_oauthbearer_sub_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SUB_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the subject is often named \"sub\", but this (optional) setting can provide a different name to use for the subject included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.sub.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.token.endpoint.url",
rust_field: "sasl_oauthbearer_token_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The URL for the OAuth/OIDC identity provider. If the URL is HTTP(S)-based, it is the issuer's token endpoint URL to which requests will be made to login based on the configuration in <code>sasl.oauthbearer.jwt.retriever.class</code>. If the URL is file-based, it specifies a file containing an access token (in JWT serialized form) issued by the OAuth/OIDC identity provider to use for authorization.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.token.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.url",
rust_field: "sasl_oauthbearer_jwks_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth/OIDC provider URL from which the provider's <a href=\"https://datatracker.ietf.org/doc/html/rfc7517#section-5\">JWKS (JSON Web Key Set)</a> can be retrieved. The URL can be HTTP(S)-based or file-based. If the URL is HTTP(S)-based, the JWKS data will be retrieved from the OAuth/OIDC provider via the configured URL on broker startup. All then-current keys will be cached on the broker for incoming requests. If an authentication request is received for a JWT that includes a \"kid\" header claim value that isn't yet in the cache, the JWKS endpoint will be queried again on demand. However, the broker polls the URL every sasl.oauthbearer.jwks.endpoint.refresh.ms milliseconds to refresh the cache with any forthcoming keys before any JWT requests that include them are received. If the URL is file-based, the broker will load the JWKS file from a configured location on startup. In the event that the JWT includes a \"kid\" header value that isn't in the JWKS file, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwks.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.refresh.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_refresh_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the broker to wait between refreshing its JWKS (JSON Web Key Set) cache that contains the keys to verify the signature of the JWT.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwks.endpoint.refresh.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between attempts to retrieve the JWKS (JSON Web Key Set) from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between JWKS (JSON Web Key Set) retrieval attempts from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.clock.skew.seconds",
rust_field: "sasl_oauthbearer_clock_skew_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in seconds to allow for differences between the time of the OAuth/OIDC identity provider and the broker.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.clock.skew.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.audience",
rust_field: "sasl_oauthbearer_expected_audience",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. The JWT will be inspected for the standard OAuth \"aud\" claim and if this value is set, the broker will match the value from JWT's \"aud\" claim to see if there is an exact match. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.expected.audience",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.issuer",
rust_field: "sasl_oauthbearer_expected_issuer",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting for the broker to use to verify that the JWT was created by the expected issuer. The JWT will be inspected for the standard OAuth \"iss\" claim and if this value is set, the broker will match it exactly against what is in the JWT's \"iss\" claim. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.expected.issuer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.header.urlencode",
rust_field: "sasl_oauthbearer_header_urlencode",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_HEADER_URLENCODE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting to enable the OAuth client to URL-encode the client_id and client_secret in the authorization header in accordance with RFC6749, see <a href=\"https://datatracker.ietf.org/doc/html/rfc6749#section-2.3.1\">here</a> for more details. The default value is set to 'false' for backward compatibility",
source: "https://kafka.apache.org/43/configuration/producer-configs/#producerconfigs_sasl.oauthbearer.header.urlencode",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.nodelay",
rust_field: "socket_tcp_nodelay",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets TCP_NODELAY on broker TCP connections.",
source: "kacrab-runtime://config/socket.tcp.nodelay",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.quickack",
rust_field: "socket_tcp_quickack",
kafka_type: "boolean",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_QUICKACK after a broker TCP connection is established.",
source: "kacrab-runtime://config/socket.tcp.quickack",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.notsent.lowat.bytes",
rust_field: "socket_tcp_notsent_lowat_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android.",
documentation: "Sets TCP_NOTSENT_LOWAT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.notsent.lowat.bytes",
platforms: &["linux", "android"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.user.timeout.ms",
rust_field: "socket_tcp_user_timeout_ms",
kafka_type: "long",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_USER_TIMEOUT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.user.timeout.ms",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.congestion",
rust_field: "socket_tcp_congestion",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, freebsd.",
documentation: "Sets the TCP congestion-control algorithm on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.congestion",
platforms: &["linux", "freebsd"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.reuse.address",
rust_field: "socket_reuse_address",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets SO_REUSEADDR before connecting broker TCP sockets.",
source: "kacrab-runtime://config/socket.reuse.address",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.read.buffer.capacity.bytes",
rust_field: "socket_read_buffer_capacity_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime option generated from the runtime config overlay.",
documentation: "Initial reusable in-process read buffer capacity for broker frame reads.",
source: "kacrab-runtime://config/socket.read.buffer.capacity.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "broker.queue.capacity",
rust_field: "broker_queue_capacity",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime option generated from the runtime config overlay.",
documentation: "Bounded pending command queue capacity for each broker IO task.",
source: "kacrab-runtime://config/broker.queue.capacity",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Producer,
origin: ConfigOrigin::KacrabRuntime,
key: "buffer.pool.capacity",
rust_field: "buffer_pool_capacity",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime option generated from the runtime config overlay.",
documentation: "Number of reusable wire read/write buffers retained per client.",
source: "kacrab-runtime://config/buffer.pool.capacity",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "bootstrap.servers",
rust_field: "bootstrap_servers",
kafka_type: "list",
default: "(none)",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A list of host/port pairs used to establish the initial connection to the Kafka cluster. Clients use this list to bootstrap and discover the full set of Kafka brokers. While the order of servers in the list does not matter, we recommend including more than one server to ensure resilience if any servers are down. This list does not need to contain the entire set of brokers, as Kafka clients automatically manage and update connections to the cluster efficiently. This list must be in the form <code>host1:port1,host2:port2,...</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_bootstrap.servers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "client.dns.lookup",
rust_field: "client_dns_lookup",
kafka_type: "string",
default: "ClientDnsLookup.USE_ALL_DNS_IPS.toString()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client uses DNS lookups. If set to <code>use_all_dns_ips</code>, connect to each returned IP address in sequence until a successful connection is established. After a disconnection, the next IP is used. Once all IPs have been used once, the client resolves the IP(s) from the hostname again (both the JVM and the OS cache DNS name lookups, however). If set to <code>resolve_canonical_bootstrap_servers_only</code>, resolve each bootstrap address into a list of canonical names. After the bootstrap phase, this behaves the same as <code>use_all_dns_ips</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_client.dns.lookup",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "group.id",
rust_field: "group_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A unique string that identifies the consumer group this consumer belongs to. This property is required if the consumer uses either the group management functionality by using <code>subscribe(topic)</code> or the Kafka-based offset management strategy.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_group.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "group.instance.id",
rust_field: "group_instance_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A unique identifier of the consumer instance provided by the end user. Only non-empty strings are permitted. If set, the consumer is treated as a static member, which means that only one instance with this ID is allowed in the consumer group at any time. This can be used in combination with a larger session timeout to avoid group rebalances caused by transient unavailability (e.g. process restarts). If not set, the consumer will join the group as a dynamic member, which is the traditional behavior.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_group.instance.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "session.timeout.ms",
rust_field: "session_timeout_ms",
kafka_type: "int",
default: "45000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The timeout used to detect client failures when using Kafka's group management facility. The client sends periodic heartbeats to indicate its liveness to the broker. If no heartbeats are received by the broker before the expiration of this session timeout, then the broker will remove this client from the group and initiate a rebalance. Note that the value must be in the allowable range as configured in the broker configuration by <code>group.min.session.timeout.ms</code> and <code>group.max.session.timeout.ms</code>. Note that this client configuration is not supported when <code>group.protocol</code> is set to \"consumer\". In that case, session timeout is controlled by the broker config <code>group.consumer.session.timeout.ms</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_session.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "heartbeat.interval.ms",
rust_field: "heartbeat_interval_ms",
kafka_type: "int",
default: "3000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The expected time between heartbeats to the consumer coordinator when using Kafka's group management facilities. Heartbeats are used to ensure that the consumer's session stays active and to facilitate rebalancing when new consumers join or leave the group. This config is only supported if <code>group.protocol</code> is set to \"classic\". In that case, the value must be set lower than <code>session.timeout.ms</code>, but typically should be set no higher than 1/3 of that value. It can be adjusted even lower to control the expected time for normal rebalances.If <code>group.protocol</code> is set to \"consumer\", this config is not supported, as the heartbeat interval is controlled by the broker with <code>group.consumer.heartbeat.interval.ms</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_heartbeat.interval.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "partition.assignment.strategy",
rust_field: "partition_assignment_strategy",
kafka_type: "list",
default: "List.of(RangeAssignor.class, CooperativeStickyAssignor.class)",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A list of class names or class types, ordered by preference, of supported partition assignment strategies that the client will use to distribute partition ownership amongst consumer instances when group management is used. Available options are:<ul><li><code>org.apache.kafka.clients.consumer.RangeAssignor</code>: Assigns partitions on a per-topic basis.</li><li><code>org.apache.kafka.clients.consumer.RoundRobinAssignor</code>: Assigns partitions to consumers in a round-robin fashion.</li><li><code>org.apache.kafka.clients.consumer.StickyAssignor</code>: Guarantees an assignment that is maximally balanced while preserving as many existing partition assignments as possible.</li><li><code>org.apache.kafka.clients.consumer.CooperativeStickyAssignor</code>: Follows the same StickyAssignor logic, but allows for cooperative rebalancing.</li></ul><p>The default assignor is [RangeAssignor, CooperativeStickyAssignor], which will use the RangeAssignor by default, but allows upgrading to the CooperativeStickyAssignor with just a single rolling bounce that removes the RangeAssignor from the list.</p><p>Implementing the <code>org.apache.kafka.clients.consumer.ConsumerPartitionAssignor</code> interface allows you to plug in a custom assignment strategy.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_partition.assignment.strategy",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metadata.max.age.ms",
rust_field: "metadata_max_age_ms",
kafka_type: "long",
default: "5 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metadata.max.age.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "enable.auto.commit",
rust_field: "enable_auto_commit",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If true the consumer's offset will be periodically committed in the background.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_enable.auto.commit",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "auto.commit.interval.ms",
rust_field: "auto_commit_interval_ms",
kafka_type: "int",
default: "5000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The frequency in milliseconds that the consumer offsets are auto-committed to Kafka if <code>enable.auto.commit</code> is set to <code>true</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_auto.commit.interval.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "client.id",
rust_field: "client_id",
kafka_type: "string",
default: "",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "An id string to pass to the server when making requests. The purpose of this is to be able to track the source of requests beyond just ip/port by allowing a logical application name to be included in server-side request logging.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "client.rack",
rust_field: "client_rack",
kafka_type: "string",
default: "DEFAULT_CLIENT_RACK",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A rack identifier for this client. This can be any string value which indicates where this client is physically located. It corresponds with the broker config 'broker.rack'",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_client.rack",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "max.partition.fetch.bytes",
rust_field: "max_partition_fetch_bytes",
kafka_type: "int",
default: "DEFAULT_MAX_PARTITION_FETCH_BYTES",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of data per-partition the server will return. Records are fetched in batches by the consumer. If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress. The maximum record batch size accepted by the broker is defined via <code>message.max.bytes</code> (broker config) or <code>max.message.bytes</code> (topic config). See fetch.max.bytes for limiting the consumer request size.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_max.partition.fetch.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "send.buffer.bytes",
rust_field: "send_buffer_bytes",
kafka_type: "int",
default: "128 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP send buffer (SO_SNDBUF) to use when sending data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_send.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "receive.buffer.bytes",
rust_field: "receive_buffer_bytes",
kafka_type: "int",
default: "64 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP receive buffer (SO_RCVBUF) to use when reading data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_receive.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "fetch.min.bytes",
rust_field: "fetch_min_bytes",
kafka_type: "int",
default: "DEFAULT_FETCH_MIN_BYTES",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The minimum amount of data the server should return for a fetch request. If insufficient data is available the request will wait for that much data to accumulate before answering the request. The default setting of 1 byte means that fetch requests are answered as soon as that many byte(s) of data is available or the fetch request times out waiting for data to arrive. Setting this to a larger value will cause the server to wait for larger amounts of data to accumulate which can improve server throughput a bit at the cost of some additional latency. Even if the total data available in the broker exceeds fetch.min.bytes, the actual returned size may still be less than this value due to per-partition limits max.partition.fetch.bytes and max returned limits fetch.max.bytes.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_fetch.min.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "fetch.max.bytes",
rust_field: "fetch_max_bytes",
kafka_type: "int",
default: "DEFAULT_FETCH_MAX_BYTES",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of data the server should return for a fetch request. Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum. The maximum record batch size accepted by the broker is defined via <code>message.max.bytes</code> (broker config) or <code>max.message.bytes</code> (topic config). A fetch request consists of many partitions, and there is another setting that controls how much data is returned for each partition in a fetch request - see <code>max.partition.fetch.bytes</code>. Note that the consumer performs multiple fetches in parallel.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_fetch.max.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "fetch.max.wait.ms",
rust_field: "fetch_max_wait_ms",
kafka_type: "int",
default: "DEFAULT_FETCH_MAX_WAIT_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time the server will block before answering the fetch request there isn't sufficient data to immediately satisfy the requirement given by fetch.min.bytes. This config is used only for local log fetch. To tune the remote fetch maximum wait time, please refer to 'remote.fetch.max.wait.ms' broker config",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_fetch.max.wait.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.ms",
rust_field: "reconnect_backoff_ms",
kafka_type: "long",
default: "50L",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The base amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all connection attempts by the client to a broker. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>reconnect.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_reconnect.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.max.ms",
rust_field: "reconnect_backoff_max_ms",
kafka_type: "long",
default: "1000L",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_reconnect.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.ms",
rust_field: "retry_backoff_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The amount of time to wait before attempting to retry a failed request to a given topic partition. This avoids repeatedly sending requests in a tight loop under some failure scenarios. This value is the initial backoff value and will increase exponentially for each failed request, up to the <code>retry.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.max.ms",
rust_field: "retry_backoff_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time in milliseconds to wait when retrying a request to the broker that has repeatedly failed. If provided, the backoff per client will increase exponentially for each failed request, up to this maximum. To prevent all clients from being synchronized upon retry, a randomized jitter with a factor of 0.2 will be applied to the backoff, resulting in the backoff falling within a range between 20% below and 20% above the computed value. If <code>retry.backoff.ms</code> is set to be higher than <code>retry.backoff.max.ms</code>, then <code>retry.backoff.max.ms</code> will be used as a constant backoff from the beginning without any exponential increase",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "enable.metrics.push",
rust_field: "enable_metrics_push",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Whether to enable pushing of client metrics to the cluster, if the cluster has a client metrics subscription which matches this client.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_enable.metrics.push",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "auto.offset.reset",
rust_field: "auto_offset_reset",
kafka_type: "string",
default: "AutoOffsetResetStrategy.LATEST.name()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server (e.g. because that data has been deleted): <ul><li>earliest: automatically reset the offset to the earliest offset</li><li>latest: automatically reset the offset to the latest offset</li><li>by_duration:<duration>: automatically reset the offset to a configured <duration> from the current timestamp. <duration> must be specified in ISO8601 format (PnDTnHnMn.nS). Negative duration is not allowed.</li><li>none: throw exception to the consumer if no previous offset is found for the consumer's group</li><li>anything else: throw exception to the consumer.</li></ul><p>Note that altering partition numbers while setting this config to latest may cause message delivery loss since producers could start to send messages to newly added partitions (i.e. no initial offsets exist yet) before consumers reset their offsets.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_auto.offset.reset",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "check.crcs",
rust_field: "check_crcs",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Automatically check the CRC32 of the records consumed. This ensures no on-the-wire or on-disk corruption to the messages occurred. This check adds some overhead, so it may be disabled in cases seeking extreme performance.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_check.crcs",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metrics.sample.window.ms",
rust_field: "metrics_sample_window_ms",
kafka_type: "long",
default: "30000",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The window of time a metrics sample is computed over.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metrics.sample.window.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metrics.num.samples",
rust_field: "metrics_num_samples",
kafka_type: "int",
default: "2",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The number of samples maintained to compute metrics.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metrics.num.samples",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metrics.recording.level",
rust_field: "metrics_recording_level",
kafka_type: "string",
default: "Sensor.RecordingLevel.INFO.toString()",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The highest recording level for metrics. It has three levels for recording metrics - info, debug, and trace.\n \nINFO level records only essential metrics necessary for monitoring system performance and health. It collects vital data without gathering too much detail, making it suitable for production environments where minimal overhead is desired.\n\nDEBUG level records most metrics, providing more detailed information about the system's operation. It's useful for development and testing environments where you need deeper insights to debug and fine-tune the application.\n\nTRACE level records all possible metrics, capturing every detail about the system's performance and operation. It's best for controlled environments where in-depth analysis is required, though it can introduce significant overhead.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metrics.recording.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metric.reporters",
rust_field: "metric_reporters",
kafka_type: "list",
default: "JmxReporter.class.getName()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of classes to use as metrics reporters. Implementing the <code>org.apache.kafka.common.metrics.MetricsReporter</code> interface allows plugging in classes that will be notified of new metric creation. When custom reporters are set and <code>org.apache.kafka.common.metrics.JmxReporter</code> is needed, it has to be explicitly added to the list.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metric.reporters",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "key.deserializer",
rust_field: "key_deserializer",
kafka_type: "class",
default: "(none)",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Deserializer class for key that implements the <code>org.apache.kafka.common.serialization.Deserializer</code> interface.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_key.deserializer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "value.deserializer",
rust_field: "value_deserializer",
kafka_type: "class",
default: "(none)",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Deserializer class for value that implements the <code>org.apache.kafka.common.serialization.Deserializer</code> interface.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_value.deserializer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "request.timeout.ms",
rust_field: "request_timeout_ms",
kafka_type: "int",
default: "30000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_request.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "default.api.timeout.ms",
rust_field: "default_api_timeout_ms",
kafka_type: "int",
default: "60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Specifies the timeout (in milliseconds) for client APIs. This configuration is used as the default timeout for all client operations that do not specify a <code>timeout</code> parameter.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_default.api.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.ms",
rust_field: "socket_connection_setup_timeout_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The amount of time the client will wait for the socket connection to be established. If the connection is not built before the timeout elapses, clients will close the socket channel. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>socket.connection.setup.timeout.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_socket.connection.setup.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.max.ms",
rust_field: "socket_connection_setup_timeout_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time the client will wait for the socket connection to be established. The connection setup timeout will increase exponentially for each consecutive connection failure up to this maximum. To avoid connection storms, a randomization factor of 0.2 will be applied to the timeout resulting in a random range between 20% below and 20% above the computed value.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_socket.connection.setup.timeout.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "connections.max.idle.ms",
rust_field: "connections_max_idle_ms",
kafka_type: "long",
default: "9 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Close idle connections after the number of milliseconds specified by this config.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_connections.max.idle.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "interceptor.classes",
rust_field: "interceptor_classes",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of classes to use as interceptors. Implementing the <code>org.apache.kafka.clients.consumer.ConsumerInterceptor</code> interface allows you to intercept (and possibly mutate) records received by the consumer. By default, there are no interceptors.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_interceptor.classes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "max.poll.records",
rust_field: "max_poll_records",
kafka_type: "int",
default: "DEFAULT_MAX_POLL_RECORDS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum number of records returned in a single call to poll(). Note, that <code>max.poll.records</code> does not impact the underlying fetching behavior. The consumer will cache the records from each fetch request and returns them incrementally from each poll.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_max.poll.records",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "max.poll.interval.ms",
rust_field: "max_poll_interval_ms",
kafka_type: "int",
default: "300000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum delay between invocations of poll() when using consumer group management. This places an upper bound on the amount of time that the consumer can be idle before fetching more records. If poll() is not called before expiration of this timeout, then the consumer is considered failed and the group will rebalance in order to reassign the partitions to another member. For consumers using a non-null <code>group.instance.id</code> which reach this timeout, partitions will not be immediately reassigned. Instead, the consumer will stop sending heartbeats and partitions will be reassigned after expiration of the session timeout (defined by the client config <code>session.timeout.ms</code> if using the Classic rebalance protocol, or by the broker config <code>group.consumer.session.timeout.ms</code> if using the Consumer protocol). This mirrors the behavior of a static consumer which has shutdown.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_max.poll.interval.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "exclude.internal.topics",
rust_field: "exclude_internal_topics",
kafka_type: "boolean",
default: "DEFAULT_EXCLUDE_INTERNAL_TOPICS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Whether internal topics matching a subscribed pattern should be excluded from the subscription. It is always possible to explicitly subscribe to an internal topic.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_exclude.internal.topics",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "isolation.level",
rust_field: "isolation_level",
kafka_type: "string",
default: "DEFAULT_ISOLATION_LEVEL",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how to read messages written transactionally. If set to <code>read_committed</code>, consumer.poll() will only return transactional messages which have been committed. If set to <code>read_uncommitted</code> (the default), consumer.poll() will return all messages, even transactional messages which have been aborted. Non-transactional messages will be returned unconditionally in either mode. <p>Messages will always be returned in offset order. Hence, in <code>read_committed</code> mode, consumer.poll() will only return messages up to the last stable offset (LSO), which is the one less than the offset of the first open transaction. In particular any messages appearing after messages belonging to ongoing transactions will be withheld until the relevant transaction has been completed. As a result, <code>read_committed</code> consumers will not be able to read up to the high watermark when there are in flight transactions.</p><p> Further, when in <code>read_committed</code> the seekToEnd method will return the LSO</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_isolation.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "allow.auto.create.topics",
rust_field: "allow_auto_create_topics",
kafka_type: "boolean",
default: "DEFAULT_ALLOW_AUTO_CREATE_TOPICS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Allow automatic topic creation on the broker when subscribing to or assigning a topic. A topic being subscribed to will be automatically created only if the broker allows for it using <code>auto.create.topics.enable</code> broker configuration.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_allow.auto.create.topics",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "group.protocol",
rust_field: "group_protocol",
kafka_type: "string",
default: "DEFAULT_GROUP_PROTOCOL",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The group protocol that the consumer uses. The supported values are <code>classic</code> or <code>consumer</code>. The default value is <code>classic</code>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_group.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "group.remote.assignor",
rust_field: "group_remote_assignor",
kafka_type: "string",
default: "DEFAULT_GROUP_REMOTE_ASSIGNOR",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The name of the server-side assignor to use. If not specified, the group coordinator will pick the first assignor defined in the broker config group.consumer.assignors.This configuration is applied only if <code>group.protocol</code> is set to \"consumer\".",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_group.remote.assignor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "security.providers",
rust_field: "security_providers",
kafka_type: "string",
default: "null",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of configurable creator classes each returning a provider implementing security algorithms. These classes should implement the <code>org.apache.kafka.common.security.auth.SecurityProviderCreator</code> interface.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_security.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "security.protocol",
rust_field: "security_protocol",
kafka_type: "string",
default: "CommonClientConfigs.DEFAULT_SECURITY_PROTOCOL",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "Protocol used to communicate with brokers.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_security.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.strategy",
rust_field: "metadata_recovery_strategy",
kafka_type: "string",
default: "CommonClientConfigs.DEFAULT_METADATA_RECOVERY_STRATEGY",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client recovers when none of the brokers known to it is available. If set to <code>none</code>, the client fails. If set to <code>rebootstrap</code>, the client repeats the bootstrap process using <code>bootstrap.servers</code>. Rebootstrapping is useful when a client communicates with brokers so infrequently that the set of brokers may change entirely before the client refreshes metadata. Metadata recovery is triggered when all last-known brokers appear unavailable simultaneously. Brokers appear unavailable when disconnected and no current retry attempt is in-progress. Consider increasing <code>reconnect.backoff.ms</code> and <code>reconnect.backoff.max.ms</code> and decreasing <code>socket.connection.setup.timeout.ms</code> and <code>socket.connection.setup.timeout.max.ms</code> for the client. Rebootstrap is also triggered if connection cannot be established to any of the brokers for <code>metadata.recovery.rebootstrap.trigger.ms</code> milliseconds or if server requests rebootstrap.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metadata.recovery.strategy",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.rebootstrap.trigger.ms",
rust_field: "metadata_recovery_rebootstrap_trigger_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_METADATA_RECOVERY_REBOOTSTRAP_TRIGGER_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If a client configured to rebootstrap using <code>metadata.recovery.strategy=rebootstrap</code> is unable to obtain metadata from any of the brokers in the last known metadata for this interval, client repeats the bootstrap process using <code>bootstrap.servers</code> configuration.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_metadata.recovery.rebootstrap.trigger.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "share.acknowledgement.mode",
rust_field: "share_acknowledgement_mode",
kafka_type: "string",
default: "ShareAcknowledgementMode.IMPLICIT.name()",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "Controls the acknowledgement mode for a share consumer. If set to <code>implicit</code>, the acknowledgement mode of the consumer is implicit and it must not use <code>org.apache.kafka.clients.consumer.ShareConsumer.acknowledge()</code> to acknowledge delivery of records. Instead, delivery is acknowledged implicitly on the next call to poll or commit. If set to <code>explicit</code>, the acknowledgement mode of the consumer is explicit and it must use <code>org.apache.kafka.clients.consumer.ShareConsumer.acknowledge()</code> to acknowledge delivery of records.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_share.acknowledgement.mode",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "share.acquire.mode",
rust_field: "share_acquire_mode",
kafka_type: "string",
default: "DEFAULT_SHARE_ACQUIRE_MODE",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "Controls the acquire mode for a share consumer. If set to <code>record_limit</code>, the number of records returned in each poll() will not exceed the value of <code>max.poll.records</code>. If set to <code>batch_optimized</code>, the number of records returned in each poll() call may exceed <code>max.poll.records</code> to align with batch boundaries for optimization.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_share.acquire.mode",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "config.providers",
rust_field: "config_providers",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Comma-separated alias names for classes implementing the <code>ConfigProvider</code> interface. This enables loading configuration data (such as passwords, API keys, and other credentials) from external sources. For example, see <a href=\"https://kafka.apache.org/documentation/#config_providers\">Configuration Providers</a>.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_config.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.protocol",
rust_field: "ssl_protocol",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_PROTOCOL",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SSL protocol used to generate the SSLContext. The default is 'TLSv1.3', which should be fine for most use cases. A typical alternative to the default is 'TLSv1.2'. Allowed values for this config are dependent on the JVM. Clients using the defaults for this config and 'ssl.enabled.protocols' will downgrade to 'TLSv1.2' if the server does not support 'TLSv1.3'. If this config is set to 'TLSv1.2', however, clients will not use 'TLSv1.3' even if it is one of the values in <code>ssl.enabled.protocols</code> and the server only supports 'TLSv1.3'.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.provider",
rust_field: "ssl_provider",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The name of the security provider used for SSL connections. Default value is the default security provider of the JVM.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.provider",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.cipher.suites",
rust_field: "ssl_cipher_suites",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "A list of cipher suites. This is a named combination of authentication, encryption, MAC and key exchange algorithm used to negotiate the security settings for a network connection using TLS or SSL network protocol. By default all the available cipher suites are supported.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.cipher.suites",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.enabled.protocols",
rust_field: "ssl_enabled_protocols",
kafka_type: "list",
default: "SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The list of protocols enabled for SSL connections. The default is 'TLSv1.2,TLSv1.3'. This means that clients and servers will prefer TLSv1.3 if both support it and fallback to TLSv1.2 otherwise (assuming both support at least TLSv1.2). This default should be fine for most use cases. If this configuration is set to an empty list, Kafka will use the protocols enabled by default in the underlying SSLEngine, which may include additional protocols depending on the JVM version. Also see the config documentation for <code>ssl.protocol</code> to understand how it can impact the TLS version negotiation behavior.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.enabled.protocols",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.type",
rust_field: "ssl_keystore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the key store file. This is optional for client. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keystore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.location",
rust_field: "ssl_keystore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the key store file. This is optional for client and can be used for two-way authentication for client.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keystore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.password",
rust_field: "ssl_keystore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The store password for the key store file. This is optional for client and only needed if 'ssl.keystore.location' is configured. Key store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keystore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.key.password",
rust_field: "ssl_key_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password of the private key in the key store file or the PEM key specified in 'ssl.keystore.key'.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.key.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.key",
rust_field: "ssl_keystore_key",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Private key in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with PKCS#8 keys. If the key is encrypted, key password must be specified using 'ssl.key.password'",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keystore.key",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.certificate.chain",
rust_field: "ssl_keystore_certificate_chain",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Certificate chain in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with a list of X.509 certificates",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keystore.certificate.chain",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.certificates",
rust_field: "ssl_truststore_certificates",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Trusted certificates in the format specified by 'ssl.truststore.type'. Default SSL engine factory supports only PEM format with X.509 certificates.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.truststore.certificates",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.type",
rust_field: "ssl_truststore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the trust store file. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.truststore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.location",
rust_field: "ssl_truststore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the trust store file.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.truststore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.password",
rust_field: "ssl_truststore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password for the trust store file. If a password is not set, trust store file configured will still be used, but integrity checking is disabled. Trust store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.truststore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.keymanager.algorithm",
rust_field: "ssl_keymanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.keymanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.trustmanager.algorithm",
rust_field: "ssl_trustmanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.trustmanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.endpoint.identification.algorithm",
rust_field: "ssl_endpoint_identification_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The endpoint identification algorithm to validate server hostname using server certificate. ",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.endpoint.identification.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.secure.random.implementation",
rust_field: "ssl_secure_random_implementation",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SecureRandom PRNG implementation to use for SSL cryptography operations. ",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.secure.random.implementation",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "ssl.engine.factory.class",
rust_field: "ssl_engine_factory_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The class of type org.apache.kafka.common.security.auth.SslEngineFactory to provide SSLEngine objects. Default value is org.apache.kafka.common.security.ssl.DefaultSslEngineFactory. Alternatively, setting this to org.apache.kafka.common.security.ssl.CommonNameLoggingSslEngineFactory will log the common name of expired SSL certificates used by clients to authenticate at any of the brokers with log level INFO. Note that this will cause a tiny delay during establishment of new connections from mTLS clients to brokers due to the extra code for examining the certificate chain provided by the client. Note further that the implementation uses a custom truststore based on the standard Java truststore and thus might be considered a security risk due to not being as mature as the standard one.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_ssl.engine.factory.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.service.name",
rust_field: "sasl_kerberos_service_name",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The Kerberos principal name that Kafka runs as. This can be defined either in Kafka's JAAS config or in Kafka's config.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.kerberos.service.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.kinit.cmd",
rust_field: "sasl_kerberos_kinit_cmd",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_KERBEROS_KINIT_CMD",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Kerberos kinit command path.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.kerberos.kinit.cmd",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.window.factor",
rust_field: "sasl_kerberos_ticket_renew_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread will sleep until the specified window factor of time from last refresh to ticket's expiry has been reached, at which time it will try to renew the ticket.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.kerberos.ticket.renew.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.jitter",
rust_field: "sasl_kerberos_ticket_renew_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Percentage of random jitter added to the renewal time.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.kerberos.ticket.renew.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.min.time.before.relogin",
rust_field: "sasl_kerberos_min_time_before_relogin",
kafka_type: "long",
default: "SaslConfigs.DEFAULT_KERBEROS_MIN_TIME_BEFORE_RELOGIN",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread sleep time between refresh attempts.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.kerberos.min.time.before.relogin",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.factor",
rust_field: "sasl_login_refresh_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login refresh thread will sleep until the specified window factor relative to the credential's lifetime has been reached, at which time it will try to refresh the credential. Legal values are between 0.5 (50%) and 1.0 (100%) inclusive; a default value of 0.8 (80%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.refresh.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.jitter",
rust_field: "sasl_login_refresh_window_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The maximum amount of random jitter relative to the credential's lifetime that is added to the login refresh thread's sleep time. Legal values are between 0 and 0.25 (25%) inclusive; a default value of 0.05 (5%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.refresh.window.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.min.period.seconds",
rust_field: "sasl_login_refresh_min_period_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_MIN_PERIOD_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The desired minimum time for the login refresh thread to wait before refreshing a credential, in seconds. Legal values are between 0 and 900 (15 minutes); a default value of 60 (1 minute) is used if no value is specified. This value and sasl.login.refresh.buffer.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.refresh.min.period.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.buffer.seconds",
rust_field: "sasl_login_refresh_buffer_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_BUFFER_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The amount of buffer time before credential expiration to maintain when refreshing a credential, in seconds. If a refresh would otherwise occur closer to expiration than the number of buffer seconds then the refresh will be moved up to maintain as much of the buffer time as possible. Legal values are between 0 and 3600 (1 hour); a default value of 300 (5 minutes) is used if no value is specified. This value and sasl.login.refresh.min.period.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.refresh.buffer.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.mechanism",
rust_field: "sasl_mechanism",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_SASL_MECHANISM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "SASL mechanism used for client connections. This may be any mechanism for which a security provider is available. GSSAPI is the default mechanism.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.mechanism",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.jaas.config",
rust_field: "sasl_jaas_config",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "JAAS login context parameters for SASL connections in the format used by JAAS configuration files. JAAS configuration file format is described <a href=\"https://docs.oracle.com/javase/8/docs/technotes/guides/security/jgss/tutorials/LoginConfigFile.html\">here</a>. The format for the value is: <code>loginModuleClass controlFlag (optionName=optionValue)*;</code>. For brokers, the config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.jaas.config=com.example.ScramLoginModule required;",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.jaas.config",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.client.callback.handler.class",
rust_field: "sasl_client_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL client callback handler class that implements the AuthenticateCallbackHandler interface.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.client.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.callback.handler.class",
rust_field: "sasl_login_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL login callback handler class that implements the AuthenticateCallbackHandler interface. For brokers, login callback handler config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.callback.handler.class=com.example.CustomScramLoginCallbackHandler",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.class",
rust_field: "sasl_login_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a class that implements the Login interface. For brokers, login config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.class=com.example.CustomScramLogin",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.connect.timeout.ms",
rust_field: "sasl_login_connect_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider connection timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.connect.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.read.timeout.ms",
rust_field: "sasl_login_read_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider read timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.read.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.max.ms",
rust_field: "sasl_login_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.ms",
rust_field: "sasl_login_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.login.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.retriever.class",
rust_field: "sasl_oauthbearer_jwt_retriever_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_RETRIEVER_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtRetriever</code> implementation used to request tokens from the identity provider.</p><p>The default configuration value represents a class that maintains backward compatibility with previous versions of Apache Kafka. The default implementation uses the configuration to determine which concrete implementation to create.<p>Other implementations that are provided include:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.ClientCredentialsJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.FileJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.JwtBearerJwtRetriever</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwt.retriever.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.validator.class",
rust_field: "sasl_oauthbearer_jwt_validator_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_VALIDATOR_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtValidator</code> implementation used to validate the JWT from the identity provider.</p><p>The default validator (<code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code>) maintains backward compatibility with previous versions of Apache Kafka. The default validator uses configuration to determine which concrete implementation to create.<p>The built-in <code>JwtValidator</code> implementations are:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.BrokerJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.ClientJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwt.validator.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope",
rust_field: "sasl_oauthbearer_scope",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This is the level of access a client application is granted to a resource or API which is included in the token request. If provided, it should match one or more scopes configured in the identity provider.</p><p>The scope was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>scope</code>. For backward compatibility, the <code>scope</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.scope</code> from configuration</li><li><code>scope</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.scope",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.id",
rust_field: "sasl_oauthbearer_client_credentials_client_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The ID (defined in/by the OAuth identity provider) to identify the client requesting the token.</p><p>The client ID was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientId</code>. For backward compatibility, the <code>clientId</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.id</code> from configuration</li><li><code>clientId</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.client.credentials.client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.secret",
rust_field: "sasl_oauthbearer_client_credentials_client_secret",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The secret (defined by either the user or preassigned, depending on the identity provider) of the client requesting the token.</p><p>The client secret was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientSecret</code>. For backward compatibility, the <code>clientSecret</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.secret</code> from configuration</li><li><code>clientSecret</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.client.credentials.client.secret",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.algorithm",
rust_field: "sasl_oauthbearer_assertion_algorithm",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The algorithm the Apache Kafka client should use to sign the assertion sent to the identity provider. It is also used as the value of the OAuth <code>alg</code> (Algorithm) header in the JWT assertion.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.aud",
rust_field: "sasl_oauthbearer_assertion_claim_aud",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The JWT <code>aud</code> (Audience) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.aud",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.exp.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_exp_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_EXP_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the future</em> for which the JWT is valid. The value is used to determine the JWT <code>exp</code> (Expiration) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>exp</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n exp = x + y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.exp.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.iss",
rust_field: "sasl_oauthbearer_assertion_claim_iss",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>iss</code> (Issuer) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.iss",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.jti.include",
rust_field: "sasl_oauthbearer_assertion_claim_jti_include",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_JTI_INCLUDE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>Flag that determines if the JWT assertion should generate a unique ID for the JWT and include it in the <code>jti</code> (JWT ID) claim.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.jti.include",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.nbf.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_nbf_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_NBF_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the past</em> from which the JWT is valid. The value is used to determine the JWT <code>nbf</code> (Not Before) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>nbf</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n nbf = x - y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.nbf.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.sub",
rust_field: "sasl_oauthbearer_assertion_claim_sub",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>sub</code> (Subject) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.claim.sub",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.file",
rust_field: "sasl_oauthbearer_assertion_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a <em>pre-generated</em> JWT assertion.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect whenthe file changes to allow for the file to be reloaded on modifications. This allows for "live" assertion rotation without restarting the Kafka client.</p><p>The file contains the assertion in the serialized, three part JWT format:</p><ol><li>The <em>header</em> section is a base 64-encoded JWT header that contains values like <code>alg</code> (Algorithm), <code>typ</code> (Type, always the literal value <code>JWT</code>), etc.</li><li>The <em>payload</em> section includes the base 64-encoded set of JWT claims, such as <code>aud</code> (Audience), <code>iss</code> (Issuer), <code>sub</code> (Subject), etc.</li><li>The <em>signature</em> section is the concatenated <em>header</em> and <em>payload</em> sections that was signed using a private key</li></ol><p>See <a href=\"https://datatracker.ietf.org/doc/html/rfc7519\">RFC 7519</a> and <a href=\"https://datatracker.ietf.org/doc/html/rfc7515\">RFC 7515</a> for more details on the JWT and JWS formats.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, all other <code>sasl.oauthbearer.assertion.</code>* configurations are ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.file",
rust_field: "sasl_oauthbearer_assertion_private_key_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a private key in the standard PEM format which is used to sign the JWT assertion sent to the identity provider.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect when the file changes to allow for the file to be reloaded on modifications. This allows for "live" private key rotation without restarting the Kafka client.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.private.key.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.passphrase",
rust_field: "sasl_oauthbearer_assertion_private_key_passphrase",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The optional passphrase to decrypt the private key file specified by <code>sasl.oauthbearer.assertion.private.key.file</code>.</p><p><em>Note</em>: If the file referred to by <code>sasl.oauthbearer.assertion.private.key.file</code> is modified on the file system at runtime and it was created with a <em>different</em> passphrase than it was previously, the client will not be able to access the private key file because the passphrase is now out of date. For that reason, when using private key passphrases, either use the same passphrase each time, or—for improved security—restart the Kafka client using the new passphrase configuration.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.private.key.passphrase",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.template.file",
rust_field: "sasl_oauthbearer_assertion_template_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This optional configuration specifies the file containing the JWT headers and/or payload claims to be used when creating the JWT assertion.</p><p>Not all identity providers require the same set of claims; some may require a given claim while others may prohibit it. In order to provide the most flexibility, this configuration allows the user to provide the static header values and claims that are to be included in the JWT.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.assertion.template.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope.claim.name",
rust_field: "sasl_oauthbearer_scope_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SCOPE_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the scope is often named \"scope\", but this (optional) setting can provide a different name to use for the scope included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.scope.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.sub.claim.name",
rust_field: "sasl_oauthbearer_sub_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SUB_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the subject is often named \"sub\", but this (optional) setting can provide a different name to use for the subject included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.sub.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.token.endpoint.url",
rust_field: "sasl_oauthbearer_token_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The URL for the OAuth/OIDC identity provider. If the URL is HTTP(S)-based, it is the issuer's token endpoint URL to which requests will be made to login based on the configuration in <code>sasl.oauthbearer.jwt.retriever.class</code>. If the URL is file-based, it specifies a file containing an access token (in JWT serialized form) issued by the OAuth/OIDC identity provider to use for authorization.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.token.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.url",
rust_field: "sasl_oauthbearer_jwks_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth/OIDC provider URL from which the provider's <a href=\"https://datatracker.ietf.org/doc/html/rfc7517#section-5\">JWKS (JSON Web Key Set)</a> can be retrieved. The URL can be HTTP(S)-based or file-based. If the URL is HTTP(S)-based, the JWKS data will be retrieved from the OAuth/OIDC provider via the configured URL on broker startup. All then-current keys will be cached on the broker for incoming requests. If an authentication request is received for a JWT that includes a \"kid\" header claim value that isn't yet in the cache, the JWKS endpoint will be queried again on demand. However, the broker polls the URL every sasl.oauthbearer.jwks.endpoint.refresh.ms milliseconds to refresh the cache with any forthcoming keys before any JWT requests that include them are received. If the URL is file-based, the broker will load the JWKS file from a configured location on startup. In the event that the JWT includes a \"kid\" header value that isn't in the JWKS file, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwks.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.refresh.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_refresh_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the broker to wait between refreshing its JWKS (JSON Web Key Set) cache that contains the keys to verify the signature of the JWT.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwks.endpoint.refresh.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between attempts to retrieve the JWKS (JSON Web Key Set) from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between JWKS (JSON Web Key Set) retrieval attempts from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.clock.skew.seconds",
rust_field: "sasl_oauthbearer_clock_skew_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in seconds to allow for differences between the time of the OAuth/OIDC identity provider and the broker.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.clock.skew.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.audience",
rust_field: "sasl_oauthbearer_expected_audience",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. The JWT will be inspected for the standard OAuth \"aud\" claim and if this value is set, the broker will match the value from JWT's \"aud\" claim to see if there is an exact match. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.expected.audience",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.issuer",
rust_field: "sasl_oauthbearer_expected_issuer",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting for the broker to use to verify that the JWT was created by the expected issuer. The JWT will be inspected for the standard OAuth \"iss\" claim and if this value is set, the broker will match it exactly against what is in the JWT's \"iss\" claim. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.expected.issuer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.header.urlencode",
rust_field: "sasl_oauthbearer_header_urlencode",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_HEADER_URLENCODE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting to enable the OAuth client to URL-encode the client_id and client_secret in the authorization header in accordance with RFC6749, see <a href=\"https://datatracker.ietf.org/doc/html/rfc6749#section-2.3.1\">here</a> for more details. The default value is set to 'false' for backward compatibility",
source: "https://kafka.apache.org/43/configuration/consumer-configs/#consumerconfigs_sasl.oauthbearer.header.urlencode",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.nodelay",
rust_field: "socket_tcp_nodelay",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets TCP_NODELAY on broker TCP connections.",
source: "kacrab-runtime://config/socket.tcp.nodelay",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.quickack",
rust_field: "socket_tcp_quickack",
kafka_type: "boolean",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_QUICKACK after a broker TCP connection is established.",
source: "kacrab-runtime://config/socket.tcp.quickack",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.notsent.lowat.bytes",
rust_field: "socket_tcp_notsent_lowat_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android.",
documentation: "Sets TCP_NOTSENT_LOWAT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.notsent.lowat.bytes",
platforms: &["linux", "android"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.user.timeout.ms",
rust_field: "socket_tcp_user_timeout_ms",
kafka_type: "long",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_USER_TIMEOUT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.user.timeout.ms",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.congestion",
rust_field: "socket_tcp_congestion",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, freebsd.",
documentation: "Sets the TCP congestion-control algorithm on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.congestion",
platforms: &["linux", "freebsd"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.reuse.address",
rust_field: "socket_reuse_address",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets SO_REUSEADDR before connecting broker TCP sockets.",
source: "kacrab-runtime://config/socket.reuse.address",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Consumer,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.read.buffer.capacity.bytes",
rust_field: "socket_read_buffer_capacity_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime option generated from the runtime config overlay.",
documentation: "Initial reusable in-process read buffer capacity for broker frame reads.",
source: "kacrab-runtime://config/socket.read.buffer.capacity.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "bootstrap.servers",
rust_field: "bootstrap_servers",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A list of host/port pairs used to establish the initial connection to the Kafka cluster. Clients use this list to bootstrap and discover the full set of Kafka brokers. While the order of servers in the list does not matter, we recommend including more than one server to ensure resilience if any servers are down. This list does not need to contain the entire set of brokers, as Kafka clients automatically manage and update connections to the cluster efficiently. This list must be in the form <code>host1:port1,host2:port2,...</code>.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_bootstrap.servers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "bootstrap.controllers",
rust_field: "bootstrap_controllers",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "A list of host/port pairs to use for establishing the initial connection to the KRaft controller quorum. This list should be in the form <code>host1:port1,host2:port2,...</code>.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_bootstrap.controllers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "client.id",
rust_field: "client_id",
kafka_type: "string",
default: "",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "An id string to pass to the server when making requests. The purpose of this is to be able to track the source of requests beyond just ip/port by allowing a logical application name to be included in server-side request logging.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metadata.max.age.ms",
rust_field: "metadata_max_age_ms",
kafka_type: "long",
default: "5 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metadata.max.age.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "send.buffer.bytes",
rust_field: "send_buffer_bytes",
kafka_type: "int",
default: "128 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP send buffer (SO_SNDBUF) to use when sending data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_send.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "receive.buffer.bytes",
rust_field: "receive_buffer_bytes",
kafka_type: "int",
default: "64 * 1024",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The size of the TCP receive buffer (SO_RCVBUF) to use when reading data. If the value is -1, the OS default will be used.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_receive.buffer.bytes",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.ms",
rust_field: "reconnect_backoff_ms",
kafka_type: "long",
default: "50L",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The base amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all connection attempts by the client to a broker. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>reconnect.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_reconnect.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "reconnect.backoff.max.ms",
rust_field: "reconnect_backoff_max_ms",
kafka_type: "long",
default: "1000L",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_reconnect.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.ms",
rust_field: "retry_backoff_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MS",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The amount of time to wait before attempting to retry a failed request to a given topic partition. This avoids repeatedly sending requests in a tight loop under some failure scenarios. This value is the initial backoff value and will increase exponentially for each failed request, up to the <code>retry.backoff.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "retry.backoff.max.ms",
rust_field: "retry_backoff_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The maximum amount of time in milliseconds to wait when retrying a request to the broker that has repeatedly failed. If provided, the backoff per client will increase exponentially for each failed request, up to this maximum. To prevent all clients from being synchronized upon retry, a randomized jitter with a factor of 0.2 will be applied to the backoff, resulting in the backoff falling within a range between 20% below and 20% above the computed value. If <code>retry.backoff.ms</code> is set to be higher than <code>retry.backoff.max.ms</code>, then <code>retry.backoff.max.ms</code> will be used as a constant backoff from the beginning without any exponential increase",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "enable.metrics.push",
rust_field: "enable_metrics_push",
kafka_type: "boolean",
default: "false",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Whether to enable pushing of client metrics to the cluster, if the cluster has a client metrics subscription which matches this client.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_enable.metrics.push",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "request.timeout.ms",
rust_field: "request_timeout_ms",
kafka_type: "int",
default: "30000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_request.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.ms",
rust_field: "socket_connection_setup_timeout_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The amount of time the client will wait for the socket connection to be established. If the connection is not built before the timeout elapses, clients will close the socket channel. This value is the initial backoff value and will increase exponentially for each consecutive connection failure, up to the <code>socket.connection.setup.timeout.max.ms</code> value.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_socket.connection.setup.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "socket.connection.setup.timeout.max.ms",
rust_field: "socket_connection_setup_timeout_max_ms",
kafka_type: "long",
default: "CommonClientConfigs.DEFAULT_SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "The maximum amount of time the client will wait for the socket connection to be established. The connection setup timeout will increase exponentially for each consecutive connection failure up to this maximum. To avoid connection storms, a randomization factor of 0.2 will be applied to the timeout resulting in a random range between 20% below and 20% above the computed value.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_socket.connection.setup.timeout.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "connections.max.idle.ms",
rust_field: "connections_max_idle_ms",
kafka_type: "long",
default: "5 * 60 * 1000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Close idle connections after the number of milliseconds specified by this config.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_connections.max.idle.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "retries",
rust_field: "retries",
kafka_type: "int",
default: "Integer.MAX_VALUE",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "It is recommended to set the value to either <code>MAX_VALUE</code> or zero, and use corresponding timeout parameters to control how long a client should retry a request. Setting a value greater than zero will cause the client to resend any request that fails with a potentially transient error. Setting a value of zero will lead to transient errors not being retried, and they will be propagated to the application to be handled.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_retries",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "default.api.timeout.ms",
rust_field: "default_api_timeout_ms",
kafka_type: "int",
default: "60000",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Specifies the timeout (in milliseconds) for client APIs. This configuration is used as the default timeout for all client operations that do not specify a <code>timeout</code> parameter.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_default.api.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metrics.sample.window.ms",
rust_field: "metrics_sample_window_ms",
kafka_type: "long",
default: "30000",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The window of time a metrics sample is computed over.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metrics.sample.window.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metrics.num.samples",
rust_field: "metrics_num_samples",
kafka_type: "int",
default: "2",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The number of samples maintained to compute metrics.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metrics.num.samples",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metric.reporters",
rust_field: "metric_reporters",
kafka_type: "list",
default: "JmxReporter.class.getName()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of classes to use as metrics reporters. Implementing the <code>org.apache.kafka.common.metrics.MetricsReporter</code> interface allows plugging in classes that will be notified of new metric creation. When custom reporters are set and <code>org.apache.kafka.common.metrics.JmxReporter</code> is needed, it has to be explicitly added to the list.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metric.reporters",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metrics.recording.level",
rust_field: "metrics_recording_level",
kafka_type: "string",
default: "Sensor.RecordingLevel.INFO.toString()",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "The highest recording level for metrics. It has three levels for recording metrics - info, debug, and trace.\n \nINFO level records only essential metrics necessary for monitoring system performance and health. It collects vital data without gathering too much detail, making it suitable for production environments where minimal overhead is desired.\n\nDEBUG level records most metrics, providing more detailed information about the system's operation. It's useful for development and testing environments where you need deeper insights to debug and fine-tune the application.\n\nTRACE level records all possible metrics, capturing every detail about the system's performance and operation. It's best for controlled environments where in-depth analysis is required, though it can introduce significant overhead.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metrics.recording.level",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "client.dns.lookup",
rust_field: "client_dns_lookup",
kafka_type: "string",
default: "ClientDnsLookup.USE_ALL_DNS_IPS.toString()",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client uses DNS lookups. If set to <code>use_all_dns_ips</code>, connect to each returned IP address in sequence until a successful connection is established. After a disconnection, the next IP is used. Once all IPs have been used once, the client resolves the IP(s) from the hostname again (both the JVM and the OS cache DNS name lookups, however). If set to <code>resolve_canonical_bootstrap_servers_only</code>, resolve each bootstrap address into a list of canonical names. After the bootstrap phase, this behaves the same as <code>use_all_dns_ips</code>.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_client.dns.lookup",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "security.providers",
rust_field: "security_providers",
kafka_type: "string",
default: "null",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "A list of configurable creator classes each returning a provider implementing security algorithms. These classes should implement the <code>org.apache.kafka.common.security.auth.SecurityProviderCreator</code> interface.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_security.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "security.protocol",
rust_field: "security_protocol",
kafka_type: "string",
default: "DEFAULT_SECURITY_PROTOCOL",
status: ConfigStatus::NativeReview,
comment: "Official Kafka client key; include in catalog and review exact Rust type/default before exposing it as stable typed API.",
documentation: "Protocol used to communicate with brokers.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_security.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.strategy",
rust_field: "metadata_recovery_strategy",
kafka_type: "string",
default: "DEFAULT_METADATA_RECOVERY_STRATEGY",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "Controls how the client recovers when none of the brokers known to it is available. If set to <code>none</code>, the client fails. If set to <code>rebootstrap</code>, the client repeats the bootstrap process using <code>bootstrap.servers</code>. Rebootstrapping is useful when a client communicates with brokers so infrequently that the set of brokers may change entirely before the client refreshes metadata. Metadata recovery is triggered when all last-known brokers appear unavailable simultaneously. Brokers appear unavailable when disconnected and no current retry attempt is in-progress. Consider increasing <code>reconnect.backoff.ms</code> and <code>reconnect.backoff.max.ms</code> and decreasing <code>socket.connection.setup.timeout.ms</code> and <code>socket.connection.setup.timeout.max.ms</code> for the client. Rebootstrap is also triggered if connection cannot be established to any of the brokers for <code>metadata.recovery.rebootstrap.trigger.ms</code> milliseconds or if server requests rebootstrap.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metadata.recovery.strategy",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "metadata.recovery.rebootstrap.trigger.ms",
rust_field: "metadata_recovery_rebootstrap_trigger_ms",
kafka_type: "long",
default: "DEFAULT_METADATA_RECOVERY_REBOOTSTRAP_TRIGGER_MS",
status: ConfigStatus::Native,
comment: "Map to a typed Rust field and support Java-style property parsing.",
documentation: "If a client configured to rebootstrap using <code>metadata.recovery.strategy=rebootstrap</code> is unable to obtain metadata from any of the brokers in the last known metadata for this interval, client repeats the bootstrap process using <code>bootstrap.servers</code> configuration.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_metadata.recovery.rebootstrap.trigger.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "config.providers",
rust_field: "config_providers",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::SkipJavaOnly,
comment: "Java/JVM class or plugin hook; Rust should expose typed traits/builders instead of accepting JVM class names.",
documentation: "Comma-separated alias names for classes implementing the <code>ConfigProvider</code> interface. This enables loading configuration data (such as passwords, API keys, and other credentials) from external sources. For example, see <a href=\"https://kafka.apache.org/documentation/#config_providers\">Configuration Providers</a>.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_config.providers",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.protocol",
rust_field: "ssl_protocol",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_PROTOCOL",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SSL protocol used to generate the SSLContext. The default is 'TLSv1.3', which should be fine for most use cases. A typical alternative to the default is 'TLSv1.2'. Allowed values for this config are dependent on the JVM. Clients using the defaults for this config and 'ssl.enabled.protocols' will downgrade to 'TLSv1.2' if the server does not support 'TLSv1.3'. If this config is set to 'TLSv1.2', however, clients will not use 'TLSv1.3' even if it is one of the values in <code>ssl.enabled.protocols</code> and the server only supports 'TLSv1.3'.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.protocol",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.provider",
rust_field: "ssl_provider",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The name of the security provider used for SSL connections. Default value is the default security provider of the JVM.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.provider",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.cipher.suites",
rust_field: "ssl_cipher_suites",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "A list of cipher suites. This is a named combination of authentication, encryption, MAC and key exchange algorithm used to negotiate the security settings for a network connection using TLS or SSL network protocol. By default all the available cipher suites are supported.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.cipher.suites",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.enabled.protocols",
rust_field: "ssl_enabled_protocols",
kafka_type: "list",
default: "SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The list of protocols enabled for SSL connections. The default is 'TLSv1.2,TLSv1.3'. This means that clients and servers will prefer TLSv1.3 if both support it and fallback to TLSv1.2 otherwise (assuming both support at least TLSv1.2). This default should be fine for most use cases. If this configuration is set to an empty list, Kafka will use the protocols enabled by default in the underlying SSLEngine, which may include additional protocols depending on the JVM version. Also see the config documentation for <code>ssl.protocol</code> to understand how it can impact the TLS version negotiation behavior.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.enabled.protocols",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.type",
rust_field: "ssl_keystore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the key store file. This is optional for client. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keystore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.location",
rust_field: "ssl_keystore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the key store file. This is optional for client and can be used for two-way authentication for client.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keystore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.password",
rust_field: "ssl_keystore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The store password for the key store file. This is optional for client and only needed if 'ssl.keystore.location' is configured. Key store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keystore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.key.password",
rust_field: "ssl_key_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password of the private key in the key store file or the PEM key specified in 'ssl.keystore.key'.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.key.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.key",
rust_field: "ssl_keystore_key",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Private key in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with PKCS#8 keys. If the key is encrypted, key password must be specified using 'ssl.key.password'",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keystore.key",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keystore.certificate.chain",
rust_field: "ssl_keystore_certificate_chain",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Certificate chain in the format specified by 'ssl.keystore.type'. Default SSL engine factory supports only PEM format with a list of X.509 certificates",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keystore.certificate.chain",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.certificates",
rust_field: "ssl_truststore_certificates",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "Trusted certificates in the format specified by 'ssl.truststore.type'. Default SSL engine factory supports only PEM format with X.509 certificates.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.truststore.certificates",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.type",
rust_field: "ssl_truststore_type",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The file format of the trust store file. The values currently supported by the default <code>ssl.engine.factory.class</code> are [JKS, PKCS12, PEM].",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.truststore.type",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.location",
rust_field: "ssl_truststore_location",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The location of the trust store file.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.truststore.location",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.truststore.password",
rust_field: "ssl_truststore_password",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The password for the trust store file. If a password is not set, trust store file configured will still be used, but integrity checking is disabled. Trust store password is not supported for PEM format.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.truststore.password",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.keymanager.algorithm",
rust_field: "ssl_keymanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.keymanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.trustmanager.algorithm",
rust_field: "ssl_trustmanager_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.trustmanager.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.endpoint.identification.algorithm",
rust_field: "ssl_endpoint_identification_algorithm",
kafka_type: "string",
default: "SslConfigs.DEFAULT_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The endpoint identification algorithm to validate server hostname using server certificate. ",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.endpoint.identification.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.secure.random.implementation",
rust_field: "ssl_secure_random_implementation",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The SecureRandom PRNG implementation to use for SSL cryptography operations. ",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.secure.random.implementation",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "ssl.engine.factory.class",
rust_field: "ssl_engine_factory_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "tls-rustls",
},
comment: "TLS key can be modeled in Rust when the TLS feature is enabled; Java store formats may need conversion/skip during design-spec.",
documentation: "The class of type org.apache.kafka.common.security.auth.SslEngineFactory to provide SSLEngine objects. Default value is org.apache.kafka.common.security.ssl.DefaultSslEngineFactory. Alternatively, setting this to org.apache.kafka.common.security.ssl.CommonNameLoggingSslEngineFactory will log the common name of expired SSL certificates used by clients to authenticate at any of the brokers with log level INFO. Note that this will cause a tiny delay during establishment of new connections from mTLS clients to brokers due to the extra code for examining the certificate chain provided by the client. Note further that the implementation uses a custom truststore based on the standard Java truststore and thus might be considered a security risk due to not being as mature as the standard one.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_ssl.engine.factory.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.service.name",
rust_field: "sasl_kerberos_service_name",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The Kerberos principal name that Kafka runs as. This can be defined either in Kafka's JAAS config or in Kafka's config.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.kerberos.service.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.kinit.cmd",
rust_field: "sasl_kerberos_kinit_cmd",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_KERBEROS_KINIT_CMD",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Kerberos kinit command path.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.kerberos.kinit.cmd",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.window.factor",
rust_field: "sasl_kerberos_ticket_renew_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread will sleep until the specified window factor of time from last refresh to ticket's expiry has been reached, at which time it will try to renew the ticket.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.kerberos.ticket.renew.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.ticket.renew.jitter",
rust_field: "sasl_kerberos_ticket_renew_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Percentage of random jitter added to the renewal time.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.kerberos.ticket.renew.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.kerberos.min.time.before.relogin",
rust_field: "sasl_kerberos_min_time_before_relogin",
kafka_type: "long",
default: "SaslConfigs.DEFAULT_KERBEROS_MIN_TIME_BEFORE_RELOGIN",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login thread sleep time between refresh attempts.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.kerberos.min.time.before.relogin",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.factor",
rust_field: "sasl_login_refresh_window_factor",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_FACTOR",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "Login refresh thread will sleep until the specified window factor relative to the credential's lifetime has been reached, at which time it will try to refresh the credential. Legal values are between 0.5 (50%) and 1.0 (100%) inclusive; a default value of 0.8 (80%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.refresh.window.factor",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.window.jitter",
rust_field: "sasl_login_refresh_window_jitter",
kafka_type: "double",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_JITTER",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The maximum amount of random jitter relative to the credential's lifetime that is added to the login refresh thread's sleep time. Legal values are between 0 and 0.25 (25%) inclusive; a default value of 0.05 (5%) is used if no value is specified. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.refresh.window.jitter",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.min.period.seconds",
rust_field: "sasl_login_refresh_min_period_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_MIN_PERIOD_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The desired minimum time for the login refresh thread to wait before refreshing a credential, in seconds. Legal values are between 0 and 900 (15 minutes); a default value of 60 (1 minute) is used if no value is specified. This value and sasl.login.refresh.buffer.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.refresh.min.period.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.refresh.buffer.seconds",
rust_field: "sasl_login_refresh_buffer_seconds",
kafka_type: "short",
default: "SaslConfigs.DEFAULT_LOGIN_REFRESH_BUFFER_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The amount of buffer time before credential expiration to maintain when refreshing a credential, in seconds. If a refresh would otherwise occur closer to expiration than the number of buffer seconds then the refresh will be moved up to maintain as much of the buffer time as possible. Legal values are between 0 and 3600 (1 hour); a default value of 300 (5 minutes) is used if no value is specified. This value and sasl.login.refresh.min.period.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.refresh.buffer.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.mechanism",
rust_field: "sasl_mechanism",
kafka_type: "string",
default: "SaslConfigs.DEFAULT_SASL_MECHANISM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "SASL mechanism used for client connections. This may be any mechanism for which a security provider is available. GSSAPI is the default mechanism.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.mechanism",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.jaas.config",
rust_field: "sasl_jaas_config",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "JAAS login context parameters for SASL connections in the format used by JAAS configuration files. JAAS configuration file format is described <a href=\"https://docs.oracle.com/javase/8/docs/technotes/guides/security/jgss/tutorials/LoginConfigFile.html\">here</a>. The format for the value is: <code>loginModuleClass controlFlag (optionName=optionValue)*;</code>. For brokers, the config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.jaas.config=com.example.ScramLoginModule required;",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.jaas.config",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.client.callback.handler.class",
rust_field: "sasl_client_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL client callback handler class that implements the AuthenticateCallbackHandler interface.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.client.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.callback.handler.class",
rust_field: "sasl_login_callback_handler_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a SASL login callback handler class that implements the AuthenticateCallbackHandler interface. For brokers, login callback handler config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.callback.handler.class=com.example.CustomScramLoginCallbackHandler",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.callback.handler.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.class",
rust_field: "sasl_login_class",
kafka_type: "class",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The fully qualified name of a class that implements the Login interface. For brokers, login config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.class=com.example.CustomScramLogin",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.connect.timeout.ms",
rust_field: "sasl_login_connect_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider connection timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.connect.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.read.timeout.ms",
rust_field: "sasl_login_read_timeout_ms",
kafka_type: "int",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the external authentication provider read timeout. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.read.timeout.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.max.ms",
rust_field: "sasl_login_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.login.retry.backoff.ms",
rust_field: "sasl_login_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.login.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.retriever.class",
rust_field: "sasl_oauthbearer_jwt_retriever_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_RETRIEVER_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtRetriever</code> implementation used to request tokens from the identity provider.</p><p>The default configuration value represents a class that maintains backward compatibility with previous versions of Apache Kafka. The default implementation uses the configuration to determine which concrete implementation to create.<p>Other implementations that are provided include:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.ClientCredentialsJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.FileJwtRetriever</code></li><li><code>org.apache.kafka.common.security.oauthbearer.JwtBearerJwtRetriever</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwt.retriever.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwt.validator.class",
rust_field: "sasl_oauthbearer_jwt_validator_class",
kafka_type: "class",
default: "DEFAULT_SASL_OAUTHBEARER_JWT_VALIDATOR_CLASS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The fully-qualified class name of a <code>JwtValidator</code> implementation used to validate the JWT from the identity provider.</p><p>The default validator (<code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code>) maintains backward compatibility with previous versions of Apache Kafka. The default validator uses configuration to determine which concrete implementation to create.<p>The built-in <code>JwtValidator</code> implementations are:</p><ul><li><code>org.apache.kafka.common.security.oauthbearer.BrokerJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.ClientJwtValidator</code></li><li><code>org.apache.kafka.common.security.oauthbearer.DefaultJwtValidator</code></li></ul>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwt.validator.class",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope",
rust_field: "sasl_oauthbearer_scope",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This is the level of access a client application is granted to a resource or API which is included in the token request. If provided, it should match one or more scopes configured in the identity provider.</p><p>The scope was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>scope</code>. For backward compatibility, the <code>scope</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.scope</code> from configuration</li><li><code>scope</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.scope",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.id",
rust_field: "sasl_oauthbearer_client_credentials_client_id",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The ID (defined in/by the OAuth identity provider) to identify the client requesting the token.</p><p>The client ID was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientId</code>. For backward compatibility, the <code>clientId</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.id</code> from configuration</li><li><code>clientId</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.client.credentials.client.id",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.client.credentials.client.secret",
rust_field: "sasl_oauthbearer_client_credentials_client_secret",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The secret (defined by either the user or preassigned, depending on the identity provider) of the client requesting the token.</p><p>The client secret was previously stored as part of the <code>sasl.jaas.config</code> configuration with the key <code>clientSecret</code>. For backward compatibility, the <code>clientSecret</code> JAAS option can still be used, but it is deprecated and will be removed in a future version.</p><p>Order of precedence:</p><ul><li><code>sasl.oauthbearer.client.credentials.client.secret</code> from configuration</li><li><code>clientSecret</code> from JAAS</li></ul>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.client.credentials.client.secret",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.algorithm",
rust_field: "sasl_oauthbearer_assertion_algorithm",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_ALGORITHM",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The algorithm the Apache Kafka client should use to sign the assertion sent to the identity provider. It is also used as the value of the OAuth <code>alg</code> (Algorithm) header in the JWT assertion.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.algorithm",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.aud",
rust_field: "sasl_oauthbearer_assertion_claim_aud",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The JWT <code>aud</code> (Audience) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.aud",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.exp.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_exp_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_EXP_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the future</em> for which the JWT is valid. The value is used to determine the JWT <code>exp</code> (Expiration) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>exp</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n exp = x + y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.exp.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.iss",
rust_field: "sasl_oauthbearer_assertion_claim_iss",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>iss</code> (Issuer) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.iss",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.jti.include",
rust_field: "sasl_oauthbearer_assertion_claim_jti_include",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_JTI_INCLUDE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>Flag that determines if the JWT assertion should generate a unique ID for the JWT and include it in the <code>jti</code> (JWT ID) claim.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.jti.include",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.nbf.seconds",
rust_field: "sasl_oauthbearer_assertion_claim_nbf_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_ASSERTION_CLAIM_NBF_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The number of seconds <em>in the past</em> from which the JWT is valid. The value is used to determine the JWT <code>nbf</code> (Not Before) claim based on the current system time when the JWT is created.</p><p>The formula to generate the <code>nbf</code> claim is very simple:</p><pre>Let:\n\n x = the current timestamp in seconds, on client\n y = the value of this configuration\n\nThen:\n\n nbf = x - y\n</pre><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.nbf.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.claim.sub",
rust_field: "sasl_oauthbearer_assertion_claim_sub",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The value to be used as the <code>sub</code> (Subject) claim which will be included in the client JWT assertion created locally.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.claim.sub",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.file",
rust_field: "sasl_oauthbearer_assertion_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a <em>pre-generated</em> JWT assertion.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect whenthe file changes to allow for the file to be reloaded on modifications. This allows for "live" assertion rotation without restarting the Kafka client.</p><p>The file contains the assertion in the serialized, three part JWT format:</p><ol><li>The <em>header</em> section is a base 64-encoded JWT header that contains values like <code>alg</code> (Algorithm), <code>typ</code> (Type, always the literal value <code>JWT</code>), etc.</li><li>The <em>payload</em> section includes the base 64-encoded set of JWT claims, such as <code>aud</code> (Audience), <code>iss</code> (Issuer), <code>sub</code> (Subject), etc.</li><li>The <em>signature</em> section is the concatenated <em>header</em> and <em>payload</em> sections that was signed using a private key</li></ol><p>See <a href=\"https://datatracker.ietf.org/doc/html/rfc7519\">RFC 7519</a> and <a href=\"https://datatracker.ietf.org/doc/html/rfc7515\">RFC 7515</a> for more details on the JWT and JWS formats.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, all other <code>sasl.oauthbearer.assertion.</code>* configurations are ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.file",
rust_field: "sasl_oauthbearer_assertion_private_key_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>File that contains a private key in the standard PEM format which is used to sign the JWT assertion sent to the identity provider.</p><p>The underlying implementation caches the file contents to avoid the performance hit of loading the file on each access. The caching mechanism will detect when the file changes to allow for the file to be reloaded on modifications. This allows for "live" private key rotation without restarting the Kafka client.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.private.key.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.private.key.passphrase",
rust_field: "sasl_oauthbearer_assertion_private_key_passphrase",
kafka_type: "password",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>The optional passphrase to decrypt the private key file specified by <code>sasl.oauthbearer.assertion.private.key.file</code>.</p><p><em>Note</em>: If the file referred to by <code>sasl.oauthbearer.assertion.private.key.file</code> is modified on the file system at runtime and it was created with a <em>different</em> passphrase than it was previously, the client will not be able to access the private key file because the passphrase is now out of date. For that reason, when using private key passphrases, either use the same passphrase each time, or—for improved security—restart the Kafka client using the new passphrase configuration.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.private.key.passphrase",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.assertion.template.file",
rust_field: "sasl_oauthbearer_assertion_template_file",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "<p>This optional configuration specifies the file containing the JWT headers and/or payload claims to be used when creating the JWT assertion.</p><p>Not all identity providers require the same set of claims; some may require a given claim while others may prohibit it. In order to provide the most flexibility, this configuration allows the user to provide the static header values and claims that are to be included in the JWT.</p><p><em>Note</em>: If a value for <code>sasl.oauthbearer.assertion.file</code> is provided, this configuration will be ignored.</p>",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.assertion.template.file",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.scope.claim.name",
rust_field: "sasl_oauthbearer_scope_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SCOPE_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the scope is often named \"scope\", but this (optional) setting can provide a different name to use for the scope included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.scope.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.sub.claim.name",
rust_field: "sasl_oauthbearer_sub_claim_name",
kafka_type: "string",
default: "DEFAULT_SASL_OAUTHBEARER_SUB_CLAIM_NAME",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth claim for the subject is often named \"sub\", but this (optional) setting can provide a different name to use for the subject included in the JWT payload's claims if the OAuth/OIDC provider uses a different name for that claim.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.sub.claim.name",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.token.endpoint.url",
rust_field: "sasl_oauthbearer_token_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The URL for the OAuth/OIDC identity provider. If the URL is HTTP(S)-based, it is the issuer's token endpoint URL to which requests will be made to login based on the configuration in <code>sasl.oauthbearer.jwt.retriever.class</code>. If the URL is file-based, it specifies a file containing an access token (in JWT serialized form) issued by the OAuth/OIDC identity provider to use for authorization.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.token.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.url",
rust_field: "sasl_oauthbearer_jwks_endpoint_url",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The OAuth/OIDC provider URL from which the provider's <a href=\"https://datatracker.ietf.org/doc/html/rfc7517#section-5\">JWKS (JSON Web Key Set)</a> can be retrieved. The URL can be HTTP(S)-based or file-based. If the URL is HTTP(S)-based, the JWKS data will be retrieved from the OAuth/OIDC provider via the configured URL on broker startup. All then-current keys will be cached on the broker for incoming requests. If an authentication request is received for a JWT that includes a \"kid\" header claim value that isn't yet in the cache, the JWKS endpoint will be queried again on demand. However, the broker polls the URL every sasl.oauthbearer.jwks.endpoint.refresh.ms milliseconds to refresh the cache with any forthcoming keys before any JWT requests that include them are received. If the URL is file-based, the broker will load the JWKS file from a configured location on startup. In the event that the JWT includes a \"kid\" header value that isn't in the JWKS file, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwks.endpoint.url",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.refresh.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_refresh_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the broker to wait between refreshing its JWKS (JSON Web Key Set) cache that contains the keys to verify the signature of the JWT.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwks.endpoint.refresh.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_max_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the maximum wait between attempts to retrieve the JWKS (JSON Web Key Set) from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
rust_field: "sasl_oauthbearer_jwks_endpoint_retry_backoff_ms",
kafka_type: "long",
default: "DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in milliseconds for the initial wait between JWKS (JSON Web Key Set) retrieval attempts from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.jwks.endpoint.retry.backoff.ms",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.clock.skew.seconds",
rust_field: "sasl_oauthbearer_clock_skew_seconds",
kafka_type: "int",
default: "DEFAULT_SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) value in seconds to allow for differences between the time of the OAuth/OIDC identity provider and the broker.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.clock.skew.seconds",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.audience",
rust_field: "sasl_oauthbearer_expected_audience",
kafka_type: "list",
default: "List.of()",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. The JWT will be inspected for the standard OAuth \"aud\" claim and if this value is set, the broker will match the value from JWT's \"aud\" claim to see if there is an exact match. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.expected.audience",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.expected.issuer",
rust_field: "sasl_oauthbearer_expected_issuer",
kafka_type: "string",
default: "null",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting for the broker to use to verify that the JWT was created by the expected issuer. The JWT will be inspected for the standard OAuth \"iss\" claim and if this value is set, the broker will match it exactly against what is in the JWT's \"iss\" claim. If there is no match, the broker will reject the JWT and authentication will fail.",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.expected.issuer",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::Kafka,
key: "sasl.oauthbearer.header.urlencode",
rust_field: "sasl_oauthbearer_header_urlencode",
kafka_type: "boolean",
default: "DEFAULT_SASL_OAUTHBEARER_HEADER_URLENCODE",
status: ConfigStatus::FeatureGated {
feature: "sasl",
},
comment: "SASL key can be modeled in Rust when SASL support is implemented.",
documentation: "The (optional) setting to enable the OAuth client to URL-encode the client_id and client_secret in the authorization header in accordance with RFC6749, see <a href=\"https://datatracker.ietf.org/doc/html/rfc6749#section-2.3.1\">here</a> for more details. The default value is set to 'false' for backward compatibility",
source: "https://kafka.apache.org/43/configuration/admin-configs/#adminclientconfigs_sasl.oauthbearer.header.urlencode",
platforms: &[],
feature: None,
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.nodelay",
rust_field: "socket_tcp_nodelay",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets TCP_NODELAY on broker TCP connections.",
source: "kacrab-runtime://config/socket.tcp.nodelay",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.quickack",
rust_field: "socket_tcp_quickack",
kafka_type: "boolean",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_QUICKACK after a broker TCP connection is established.",
source: "kacrab-runtime://config/socket.tcp.quickack",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.notsent.lowat.bytes",
rust_field: "socket_tcp_notsent_lowat_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android.",
documentation: "Sets TCP_NOTSENT_LOWAT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.notsent.lowat.bytes",
platforms: &["linux", "android"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.user.timeout.ms",
rust_field: "socket_tcp_user_timeout_ms",
kafka_type: "long",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, android, fuchsia, cygwin.",
documentation: "Sets TCP_USER_TIMEOUT on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.user.timeout.ms",
platforms: &["linux", "android", "fuchsia", "cygwin"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.tcp.congestion",
rust_field: "socket_tcp_congestion",
kafka_type: "string",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay. Available on linux, freebsd.",
documentation: "Sets the TCP congestion-control algorithm on supported broker TCP sockets.",
source: "kacrab-runtime://config/socket.tcp.congestion",
platforms: &["linux", "freebsd"],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.reuse.address",
rust_field: "socket_reuse_address",
kafka_type: "boolean",
default: "true",
status: ConfigStatus::Native,
comment: "Kacrab runtime socket option generated from the runtime config overlay.",
documentation: "Sets SO_REUSEADDR before connecting broker TCP sockets.",
source: "kacrab-runtime://config/socket.reuse.address",
platforms: &[],
feature: Some("socket2"),
},
ConfigEntry {
client: ClientKind::Admin,
origin: ConfigOrigin::KacrabRuntime,
key: "socket.read.buffer.capacity.bytes",
rust_field: "socket_read_buffer_capacity_bytes",
kafka_type: "int",
default: "null",
status: ConfigStatus::Native,
comment: "Kacrab runtime option generated from the runtime config overlay.",
documentation: "Initial reusable in-process read buffer capacity for broker frame reads.",
source: "kacrab-runtime://config/socket.read.buffer.capacity.bytes",
platforms: &[],
feature: None,
},
];
/// Returns the official Kafka config catalog for one client family.
#[must_use]
pub const fn catalog_for(client: ClientKind) -> &'static [ConfigEntry] {
match client {
ClientKind::Producer => PRODUCER_CONFIGS,
ClientKind::Consumer => CONSUMER_CONFIGS,
ClientKind::Admin => ADMIN_CONFIGS,
}
}