# Dapr v1.17.15

2026-10-08 · [Original release notes](https://github.com/dapr/dapr/releases/tag/v1.17.15) · [Full summary](https://ratatosk.io/en/releases/dapr/v1.17.15)

Breaking changes 3 · Important fixes 6 · Enhancements 1 · Other changes 1

## Breaking changes (3)

### Azure Event Hubs handler failures retried before checkpointing

- Affects: Azure Event Hubs pub/sub or input binding

When a handler returned `RETRY`, otherwise failed, or was still handling an event when the sidecar crashed or partition ownership was lost, the event could be checkpointed and never redelivered. Failures now retry with the configured backoff until success or subscription cancellation, and checkpoint progress advances only through contiguous successfully handled events or batches.

> The Event Hubs pub/sub and input binding components now advance a partition's checkpoint only through contiguous, successfully-handled events or batches:
> - A handler failure is retried with the configured backoff until it succeeds or the subscription is cancelled, instead of being dropped and checkpointed anyway.

### Azure Event Hubs `maxConcurrentHandlers` limit added

- Affects: Azure Event Hubs pub/sub and input binding components

By default, further receives pause once 100 received events are not yet checkpoint-eligible.

> - A new `maxConcurrentHandlers` option (default `100`) bounds how many received-but-not-yet-checkpoint-eligible events can be in flight at once, pausing further receives once the bound is reached.

### Azure Event Hubs checkpoints now require successful handling

- Affects: Azure Event Hubs pub/sub and input bindings

Previously, with `enableInOrderMessageDelivery: false`, checkpointing was fire-and-forget and independent of delivery; with it set to `true`, a handler’s `RETRY` response was still checkpointed.

> `enableInOrderMessageDelivery: false` remains the default and continues to control ordering only — it no longer has any bearing on whether a checkpoint requires success.

## Important fixes (6)

### [Silent failure] Azure Event Hubs checkpoints now require successful handling

- Affects: Azure Event Hubs pub/sub and input-binding consumers

A `RETRY` event, or one still in flight when the sidecar crashed or partition ownership was lost, could be checkpointed without an error and never redelivered. Handler failures are now retried with the configured backoff, and checkpoints advance only through contiguous successfully handled events or batches.

> - [Azure Event Hubs checkpointed messages regardless of whether the application processed them](#azure-event-hubs-checkpointed-messages-regardless-of-whether-the-application-processed-them)

### [Silent failure] Azure Event Hubs checkpointing fixed

- Affects: Azure Event Hubs pub/sub or input binding

Events returned as `RETRY`, or still in flight when the sidecar crashed or partition ownership was lost, could be checkpointed without successful handling and never redelivered, with no error surfaced. Handler failures are now retried with configured backoff until success or subscription cancellation; checkpoints advance only through contiguous successfully handled events or batches, and are skipped after cancellation or observed ownership loss.

> You were affected if you consumed messages through the Azure Event Hubs pub/sub component or received events through the Azure Event Hubs input binding.
> An event your application returned `RETRY` for, or one still in flight when the sidecar crashed or partition ownership was lost, was checkpointed and never redelivered, silently downgrading Dapr's documented at-least-once delivery guarantee ("Dapr attempts to redeliver the message until successful delivery") to at-most-once.
> No error was surfaced to the publisher or subscriber when this happened.
> Sibling pub/sub components such as Kafka and Service Bus already conditioned their commit or checkpoint on successful handling; only Event Hubs did not.
> The Azure Event Hubs pub/sub and input binding components advanced (checkpointed) their Event Hubs offsets without regard to whether the application actually handled the event successfully.
> `processEvents()` invoked the application through `handleAsync()`, but the error `handleAsync()` returned was discarded at the call site, leaving `UpdateCheckpoint()` with no condition to check before running.
> Both delivery modes were affected, in different ways:
> - With the default `enableInOrderMessageDelivery: false`, checkpointing happened fire-and-forget, independent of message delivery to the application.
> - With `enableInOrderMessageDelivery: true`, the component waited for the handler to return before checkpointing, but checkpointed anyway when the handler responded `RETRY`.

### Azure Event Hubs checkpointing now respects successful handling

- Affects: Azure Event Hubs pub/sub or input binding with concurrent event or batch handling

Previously, a failed event or batch could be dropped while its offset was checkpointed anyway. Failures are now retried with the configured backoff until they succeed or the subscription is cancelled; partition checkpoints advance only through the newest contiguous run of successful batches, and writes for each partition are serialized to prevent out-of-order races.

> - Under concurrent handling, a partition's checkpoint advances only through the newest contiguous run of successful batches, and checkpoint writes for a partition are serialized so they can no longer race each other out of order.

### [Silent failure] Azure Event Hubs checkpointing now stops after cancellation or ownership loss

- Affects: Azure Event Hubs pub/sub subscriptions and input bindings

Previously, an event returned with `RETRY`, or still in flight when the sidecar crashed or partition ownership was lost, could be checkpointed and never redelivered, silently changing delivery from at-least-once to at-most-once without surfacing an error. Checkpointing is now skipped once cancellation or observed partition ownership loss applies.

> - Checkpointing is skipped once the subscription is cancelled or partition ownership loss is observed, and a checkpoint-store failure now surfaces as an error instead of being silently swallowed.

### Azure Event Hubs checkpoint writes serialized per partition

- Affects: Azure Event Hubs pub/sub or input bindings

Under concurrent handling, checkpoint writes for the same partition could race out of order. The checkpoint now advances only through the newest contiguous run of successful batches.

> - Under concurrent handling, a partition's checkpoint advances only through the newest contiguous run of successful batches, and checkpoint writes for a partition are serialized so they can no longer race each other out of order.

### Azure Event Hubs checkpoint-store failures now surface as errors

- Affects: Azure Event Hubs pub/sub and input binding components

When checkpoint storage failed in either component, the failure was previously swallowed.

> - Checkpointing is skipped once the subscription is cancelled or partition ownership loss is observed, and a checkpoint-store failure now surfaces as an error instead of being silently swallowed.

## Enhancements (1)

- Configurable checkpoint frequency for Azure Event Hubs

## Other changes (1)

- Azure Event Hubs consumers start at the earliest retained event without a checkpoint

---

Summaries are produced by AI, so they can be wrong, and they are provided without warranty.
