Acknowledges completed work, batching successes into single requests.

Normally started for you by Zizq.Worker. Use it directly only if you are driving Zizq.Stream.Take yourself.

{:ok, acker} = Zizq.Worker.Acker.start_link(client: MyApp.Zizq)

Zizq.Worker.Acker.success(acker, job)
Zizq.Worker.Acker.failure(acker, job, message: "SMTP timeout")

Both are asynchronous: a handler should not wait on a network round trip it has no use for, and acknowledgement is not something the handler can meaningfully recover from.

Batching never delays an acknowledgement

There is no timer. A success is buffered and a flush is queued to this process immediately, which lands behind everything already in the mailbox — so a burst of completions collapses into one request while a lone completion goes out on its own, without waiting for company.

Batching then grows with load rather than with a clock: while a request is in flight the process is busy, so acknowledgements arriving meanwhile accumulate and leave together in the next one.

A flush interval would be actively harmful here. Prefetch is released by acknowledgement, so holding acknowledgements back to fill a batch throttles the throughput the batching is meant to serve.

Why successes batch and failures do not

A success carries nothing but an id, so a hundred of them fit in one request. Since the server's prefetch is released by acknowledgement, batching them directly raises how fast work can be pulled.

A failure carries a message, an error type and a stack trace that belong to one job, and the server responds with that job's new state. There is nothing to combine and failures are lower volume than successes, so failures go one at a time.

Losing acknowledgements is safe, but wasteful

In the case of a crashed worker an unacknowledged job is redelivered after the server detects the dead worker connection, so a dropped acknowledgement costs duplicated work rather than lost work. That is why transient failures are retried with backoff and permanent ones are logged and dropped: retrying a 4xx could only produce the same answer, and blocking on it would stall every acknowledgement behind it.