Struct RedisMessage 

pub struct RedisMessage { /* private fields */ }

A Redis Streams delivery, read from a consumer group via XREADGROUP or XAUTOCLAIM.

Settlement follows the republish-retry model: ack is XACK; nack(requeue = true) re-appends a copy of the entry to the same stream and then acks the original (at-least-once, so a duplicate is possible if the process crashes between the two); nack(requeue = false) acks the original to drop it.

Implementations

impl RedisMessage

pub fn id(&self) -> Option<&str>

The stream entry ID (for example 1700000000000-0) this message was read at.

pub const fn entry_id(&self) -> EntryId

The parsed entry id this message was read at.

pub fn group(&self) -> Option<&str>

The consumer group this delivery was read through, or None once the message has settled.

Trait Implementations

impl BuildContext<RedisMessage> for StreamContext

fn build(msg: &RedisMessage) -> Self

Builds the context value by reading fields out of msg.

impl Debug for RedisMessage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl IncomingMessage for RedisMessage

fn supports_nack_after(&self) -> bool

Native delayed redelivery is available only when the subscription opted into a durable ZSET delay queue with RedisStream::delayed_retry; otherwise the runtime applies its broker-agnostic deferred-republish fallback.

async fn nack_after(self, delay: Duration) -> Result<(), AckError>

Schedules the message for redelivery no sooner than delay from now via the configured ZSET delay queue (ZADD the delayed copy, then XACK the original), with the retry-count header incremented. The subscriber’s sweeper re-XADDs it to the source stream once due.

Errors

Returns AckError::Unsupported when the subscription did not opt into a delay queue, or AckError::Broker when the ZADD or XACK fails.

fn payload(&self) -> &[u8]

Returns the raw payload of the message.

fn headers(&self) -> &Headers

Returns the headers attached to the message.

async fn ack(self) -> Result<(), AckError>

Acknowledges successful processing. Consumes the message handle.

async fn nack(self, requeue: bool) -> Result<(), AckError>

Negatively acknowledges the message. When requeue is true the broker should redeliver according to its own retry policy; when false it should drop or dead-letter the message.

fn partition_key(&self) -> Option<&[u8]>

Returns the routing key the broker partitioned this message by, or None when the message carries no key.

impl Partitioned for RedisMessage

fn partition_key(&self) -> Option<&[u8]>

Returns the partition key for this item, or None if the broker should pick a partition.

impl Positioned for RedisMessage

The position of a delivery is the group cursor that redelivers it.

The cursor is exclusive (a group resumes after the id it holds), so the pinned position is the id immediately below this entry’s - seeking to it delivers this message again, followed by the entries after it. Repositioning is group-wide; see RedisGroupSeeker.

type Position = RedisGroupPosition

The position type, matching the subscription’s Seeker::Position.

fn position(&self) -> RedisGroupPosition

Returns the position of this delivery; seeking to it redelivers this message.