liveBook · Manning

At-least-once delivery

At-least-once delivery is a messaging or processing guarantee that each message or record is delivered or processed one or more times, so duplicates may occur.

How 4 Manning books explain it

Kafka Streams in Action, Second Edition

At-least-once delivery is a processing guarantee that prevents loss of records but permits a record to be processed more than once.

How it is used
Uses Kafka producer retries and consumer offset commits to prevent record loss during failures.
How deep it goes
Explains producer and consumer failure paths, commit timing, and Java implementation, but stops short of duplicate-handling strategies.
Examples
Uses producer acknowledgment timeouts, consumer restarts, committed offsets, and process-then-commit Java code.
What you can do after
Diagnose/debug with it by identifying duplicate processing after failed commits and unsafe commits during asynchronous work.

Read how Kafka Streams in Action, Second Edition explains at-least-once delivery →

Akka in Action, Second Edition

At-least-once delivery is a processing guarantee in which records may be delivered or processed more than once because retries can repeat work.

How it is used
Uses committable Kafka sources and sinks to commit offsets only after records are processed, preventing message loss.
How deep it goes
Explains offset-carrying messages, batch commit settings, and draining shutdown through concrete stream pipelines.
Examples
Uses a Kafka test3-to-test4 forwarding stream and a failed A-to-B-to-C batch to illustrate duplicates.
What you can do after
Apply it via Akka Kafka to consume, transform, produce, and commit offsets in an at-least-once stream.

Read how Akka in Action, Second Edition explains at-least-once delivery →

C# Concurrency: Asynchronous and multithreaded programming

At-least-once delivery is a message-delivery guarantee that permits duplicates but ensures a message is delivered one or more times.

How it is used
Uses persistent queues to favor retaining important work over preventing duplicate processing after crashes.
How deep it goes
Explains removal timing, crash windows, delivery trade-offs, and poison-message loops without detailing queue-provider implementations.
Examples
Uses a mail merge, a lost confirmation, and a crash between processing and queue removal as concrete failure scenarios.
What you can do after
Operate persistent queues by selecting at-least-once delivery and planning monitoring for messages that repeatedly crash processing.

Read how C# Concurrency: Asynchronous and multithreaded programming explains at-least-once delivery →

Apache Kafka in Action

At-least-once delivery is a message delivery guarantee that prevents message loss but permits duplicate delivery.

How it is used
Uses replicated acknowledgements to prioritize preventing message loss in Kafka applications.
How deep it goes
Explains configuration, acknowledgement loss, retries, and duplicates, then contrasts at-most-once and exactly-once guarantees.
Examples
Uses a lost-acknowledgement banking transaction and contrasts it with continuously produced temperature readings.
What you can do after
Operate/configure Kafka producers with acks=all and sufficient minimum in-sync replicas when duplicates are preferable to loss.

Read how Apache Kafka in Action explains at-least-once delivery →

Related concepts

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.