Crate krabka_client_consumer

Expand description

Subscribe-style consumer client for Apache Kafka in Rust.

This crate builds on krabka-client-core for transport. It adds the classic consumer-group lifecycle (JoinGroup → SyncGroup → Heartbeat → Fetch → OffsetCommit → LeaveGroup) and a built-in heartbeat task.

§Quick start

use krabka_client_consumer::{AutoOffsetReset, Consumer};
use krabka_units::millis;

let mut consumer = Consumer::builder()
    .bootstrap("localhost:9092")
    .group_id("my-group")
    .client_id("my-app")
    .auto_offset_reset(AutoOffsetReset::Earliest)
    .subscribe(["my-topic".to_string()])
    .build()
    .await?;

loop {
    let records = consumer.poll(millis(500)).await?;
    for _r in records {
        // ... handle r ...
    }
    consumer.commit_sync().await?;
}

use krabka_client_consumer::{ShareAckMode, ShareAckType, ShareConsumer};
use krabka_units::secs;

let mut consumer = ShareConsumer::builder()
    .bootstrap("localhost:9092")
    .group_id("share-workers")
    .subscribe(["jobs".to_string()])
    .ack_mode(ShareAckMode::Explicit)
    .build()
    .await?;

let records = consumer.poll(secs(1)).await?;
for record in &records {
    consumer.acknowledge(record, ShareAckType::Accept)?;
}
consumer.commit().await?;

§Capabilities and boundaries

This crate owns consumer-facing semantics: classic group membership, assignment, fetch/poll, offset commit, cooperative shutdown, and KIP-932 share-group consumption. It does not duplicate admin-client surfaces such as DescribeGroups/ListGroups. Manual partition fetches stay available through the lower-level helpers in krabka-client-core. Transactional consume-process-produce workflows use this crate’s ConsumerGroupMetadata together with krabka-client-producer’s send_offsets_to_transaction support.

§Cargo features

None for now.

Structs§

CloseOptions: How Consumer::close_with closes the consumer. Kafka’s CloseOptions (KIP-1092).
Consumer: Subscribe-style consumer handle. Construct via Consumer::builder.
ConsumerFetchMaxBytes: Positive total response-byte budget for one classic consumer fetch.
ConsumerFetchPartitionMaxBytes: Positive per-partition response-byte budget for one classic consumer fetch.
ConsumerGroupMetadata: The identity that a consumer presents to a transactional producer for KIP-447 offset-commit fencing.
ConsumerLeaveGroupTimeout: Positive, whole-millisecond classic Consumer leave-group deadline.
ConsumerRecord: One record returned by Consumer::poll.
ConsumerRetryPolicy: Validated classic Consumer startup and coordinator retry timing.
ConsumerSubscriptionMetadataRefreshInterval: Positive, whole-millisecond subscribed-topic metadata refresh cadence.
Header: A per-record header key/value pair, as the Kafka v2 record format defines it. The key is a UTF-8 string. The value is optional raw bytes.
Node: A broker of the cluster. Kafka’s Node.
OffsetAndMetadata: The offset that a commit stores for one partition. Kafka’s OffsetAndMetadata.
OffsetAndTimestamp: The offset of a timestamp search. Kafka’s OffsetAndTimestamp.
PartitionInfo: The metadata of one partition. Kafka’s PartitionInfo.
ShareConsumer: A share-group consumer. Construct via ShareConsumer::builder.
ShareConsumerFetchMaxBytes: Validated maximum response bytes for a ShareFetch.
ShareConsumerFetchMaxRecords: Validated maximum records acquired by a ShareFetch.
ShareConsumerFetchMinBytes: Validated minimum response bytes for a ShareFetch.
ShareConsumerLeaveHeartbeatTimeout: Validated deadline for the final best-effort ShareGroup leave heartbeat.
ShareConsumerRecord: One record delivered by ShareConsumer::poll.
TopicPattern: A topic pattern for Consumer::subscribe_pattern. Kafka’s subscribe(java.util.regex.Pattern).
WakeupHandle: A handle that wakes a Consumer::poll from another task. Kafka’s KafkaConsumer.wakeup.

Enums§

Assignor: A built-in partition assignor, Kafka’s partition.assignment.strategy.
AutoOffsetReset: What to do when a partition has no committed offset. Kafka’s auto.offset.reset.
ConsumerError: Errors returned by Consumer.
GroupMembershipOperation: What a closing consumer does with its group membership. Kafka’s CloseOptions.GroupMembershipOperation (KIP-1092).
GroupProtocol: The group protocol of a consumer. Kafka’s group.protocol.
IsolationLevel: Controls which records are visible to this consumer.
ShareAckMode: How acquired records are acknowledged.
ShareAckType: The disposition of an acknowledged record, with the KIP-932 wire codes.
ShareAcquireMode: How a ShareFetch applies its maximum-record limit.
TimestampType: The meaning of a record timestamp, as bit 3 of the v2 record batch attributes gives it.

Constants§

DEFAULT_CONSUMER_CLOSE_TIMEOUT: Kafka’s ConsumerUtils.DEFAULT_CLOSE_TIMEOUT_MS.
DEFAULT_CONSUMER_DEFAULT_API_TIMEOUT: Kafka’s default default.api.timeout.ms.
DEFAULT_CONSUMER_FETCH_MAX_WAIT: Kafka’s default fetch.max.wait.ms.
DEFAULT_CONSUMER_LEAVE_GROUP_TIMEOUT: Default deadline for classic Consumer best-effort group departure.
DEFAULT_CONSUMER_MAX_POLL_INTERVAL: Kafka’s default max.poll.interval.ms.
DEFAULT_CONSUMER_MAX_POLL_RECORDS: Kafka’s default max.poll.records.
DEFAULT_CONSUMER_METADATA_MAX_AGE: Kafka’s default metadata.max.age.ms.
DEFAULT_CONSUMER_SUBSCRIPTION_METADATA_REFRESH_INTERVAL: Default cadence for checking subscribed-topic metadata changes.
DEFAULT_SHARE_CONSUMER_FETCH_MAX: Default maximum response size for a ShareFetch.
DEFAULT_SHARE_CONSUMER_FETCH_MAX_RECORDS: Default maximum records acquired by a ShareFetch.
DEFAULT_SHARE_CONSUMER_FETCH_MIN: Default minimum response size for a ShareFetch.
DEFAULT_SHARE_CONSUMER_LEAVE_HEARTBEAT_TIMEOUT: Default deadline for the final best-effort ShareGroup leave heartbeat.

Traits§

ConsumerRebalanceListener: Callbacks for the partitions that a rebalance takes from or gives to the consumer. Kafka’s ConsumerRebalanceListener.

Type Aliases§

OffsetCommitCallback: The callback of an asynchronous commit. Kafka’s OffsetCommitCallback.
RebalanceListenerError: The error that a listener callback returns.