RATATOSK
← All releases

Daprv1.19.2

Security 2Breaking changes 14Important fixes 11Enhancements 1Dependency updates 1Other changes 13

Get Dapr alerts

Email is sent weekly only when there are changes to check; critical security advisories are sent immediately.

Check before upgrading

Known issues2
Redis Cluster transactions can partially apply across hash slots

A transaction is atomic only when all keys share a hash tag. Otherwise, scripts run per hash slot, and an ETag mismatch in one slot can leave writes in other slots applied; a warning is logged on the first transaction.

On Redis Cluster, a transaction is atomic only when all of its keys share a hash tag, such as `{order1}a` and `{order1}b`.
Otherwise the component runs one script for each hash slot, and an ETag mismatch in one slot can leave the writes of other slots applied. The component logs a warning about this on the first transaction.
github.com/dapr/dapr/releases/tag/v1.19.2
Store-specific ETag behavior for missing keys

An ETag set creates a key on Azure Cosmos DB, MongoDB, and Redis, and on RavenDB when it uses first-write. Deleting a missing Azure Cosmos DB item with an ETag still succeeds.

A set with an ETag on a key that does not exist behaves as in earlier releases.
On Azure Cosmos DB, MongoDB and Redis it creates the key, and on RavenDB it creates the key when the set also uses `first-write`.
On Azure Cosmos DB, a delete with an ETag on a missing item still succeeds.
github.com/dapr/dapr/releases/tag/v1.19.2

Security2

go-jose denial-of-service vulnerabilities fixed

AffectsSentry JWT issuing with operator-supplied RSA signing keys

When such a key has a modulus larger than 4096 bits, daprd and control plane services cannot load the trust bundle and stop with failed to parse JWT bundle; Sentry-generated RSA-2048 keys are unaffected.

Show release-note lines
- [Security: Fixes go-jose denial of service - CVE-2026-116587, CVE-2026-116586](#security-go-jose-denial-of-service)
github.com/dapr/dapr/releases/tag/v1.19.2

go-jose parsing vulnerabilities fixed

AffectsDapr trust-bundle and Sentry JWT parsing

The previous go-jose version had denial-of-service and JSON-parsing crash vulnerabilities on these parsing paths; this upgrade fixes them. If Sentry JWT issuing uses an operator-supplied RSA signing key larger than 4096 bits, daprd and control plane services stop with failed to parse JWT bundle; Sentry-generated RSA-2048 keys are unaffected.

Show release-note lines
## Security: go-jose denial of service
### Problem
An upstream dependency of Dapr, `github.com/go-jose/go-jose/v4`, had three vulnerabilities in v4.1.4:
- [CVE-2026-116587](https://github.com/go-jose/go-jose/security/advisories/GHSA-mgcc-cww5-fp2q) (high): denial of service when go-jose parses a JWK that contains an RSA key.
- [CVE-2026-116586](https://github.com/go-jose/go-jose/security/advisories/GHSA-vvm8-gf78-28g4) (medium): a crash during JSON parsing.
- [CVE-2026-116585](https://github.com/go-jose/go-jose/security/advisories/GHSA-4w3g-jfj2-cw2q) (medium): a panic during CBC-HMAC processing.
### Impact
Dapr calls go-jose only through `go-spiffe`. It parses the JWKS in the trust bundle when the trust anchors load, and it parses the JWT that Sentry issues to the sidecar. These inputs come from the Dapr control plane, not from application requests.
CVE-2026-116587 and CVE-2026-116586 are on these paths in daprd and in each control plane service. Both are denial of service. CVE-2026-116585 is in JWE decryption, which Dapr does not use.
### Root Cause
Dapr pinned go-jose at v4.1.4. go-jose v4.1.5 fixes CVE-2026-116586 and CVE-2026-116585, and v4.1.6 fixes CVE-2026-116587.
### Solution
This release upgrades `github.com/go-jose/go-jose/v4` from v4.1.4 to v4.1.6.
go-jose v4.1.6 rejects an RSA key with a modulus larger than 4096 bits in a JWK. This affects you only if both of these conditions are true:
- JWT issuing is on in Sentry.
- You supply your own RSA JWT signing key that is larger than 4096 bits.
In that case, daprd and the control plane services cannot load the trust bundle, and they stop with the error `failed to parse JWT bundle`. Before you upgrade, replace the key with an RSA key of 4096 bits or fewer, or with an EC key. The JWT signing key that Sentry generates is RSA-2048, and it is not affected.
github.com/dapr/dapr/releases/tag/v1.19.2

Breaking changes14

State-store ETag and first-write checks made consistent

AffectsSetups using ETags or first-write concurrency with AWS DynamoDB, Azure Cosmos DB, CockroachDB, etcd, in-memory, MongoDB, MySQL, Oracle Database, PostgreSQL (v1 and v2), RavenDB, Redis, SQLite, or SQL Server (v1 and v2)

Previously, expired keys could still match ETags, and failed checks could allow writes or partial transactions, skip concurrent etcd writes while reporting success, or leave CockroachDB ETags stale. Now expired keys do not match ETags; first-write succeeds for missing or expired keys and fails otherwise, and failed checks return an ETag mismatch (409 over HTTP or Aborted over gRPC).

Show release-note lines
## State stores did not enforce ETags and first-write consistently
### Problem
Several state store components accepted a write or a delete that its ETag or its `first-write` concurrency option should have rejected, or rejected one that should have succeeded.
The behavior differed from one component to the next:
- **Expired keys.** A key whose TTL had passed, but that the store had not removed yet, still matched an ETag. A set or a delete with that ETag succeeded on a key that a read no longer returned. On some stores a `first-write` set on such a key was rejected as if the key still existed.
- **Transactions.** On Redis, a transaction with a failed ETag check still applied its other operations. On AWS DynamoDB and RavenDB, a delete inside a transaction ignored its ETag. On MongoDB, a transaction that failed to commit reported success.
- **Concurrent writes.** etcd read the key to check the ETag or `first-write` and then wrote in a separate request. When another write landed in between, a set, a delete or one operation of a transaction was skipped and the request still reported success.
- **Stale ETags.** On CockroachDB, every set without an ETag on an existing key left the ETag at the same value, so an ETag read before the write still matched after it.
- **Error type.** On SQL Server, a rejected `first-write` set returned a generic error. On Azure Cosmos DB and AWS DynamoDB, an ETag mismatch inside a transaction returned a generic error.
### Impact
You were affected if you use ETags or `first-write` concurrency with one of these state stores: AWS DynamoDB, Azure Cosmos DB, CockroachDB, etcd, in-memory, MongoDB, MySQL, Oracle Database, PostgreSQL (v1 and v2), RavenDB, Redis, SQLite or SQL Server (v1 and v2).
Depending on the store, a concurrent update could be lost without an error, a transaction could be applied in part, or a caller could not tell an ETag mismatch from another failure.
After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.
Requests that do not set an ETag and do not use `first-write` behave as before.
### Root Cause
The components checked the ETag against the stored row without checking whether the row had expired.
Some components checked the ETag in one request and wrote in another, or sent each operation of a transaction with its own condition, so a failed condition did not stop the other operations.
### Solution
Dapr now uses components-contrib v1.19.2, in which an ETag does not match a key that has expired, a `first-write` set succeeds on a key that is missing or expired and fails otherwise, and a failed check returns an ETag mismatch.
- [State stores did not enforce ETags and first-write consistently](#state-stores-did-not-enforce-etags-and-first-write-consistently)
github.com/dapr/dapr/releases/tag/v1.19.2

AWS DynamoDB state store no longer matches ETags on expired items

AffectsAWS DynamoDB state store set and delete operations

Previously, an expired item could still match an ETag, allowing a set or delete to succeed even though a read no longer returned the item. Now such requests fail with an ETag mismatch: HTTP status 409 or gRPC code Aborted.

Evidence“After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.” dapr/dapr/releases/tag/v1.19.2 ↗
Show release-note lines
| AWS DynamoDB | A set or a delete with an ETag no longer matches an expired item. A `first-write` set succeeds on an expired item. A delete in a transaction checks its ETag. A failed condition in a transaction returns an ETag mismatch. |
github.com/dapr/dapr/releases/tag/v1.19.2

AWS DynamoDB transactional delete ETag check fixed

AffectsAWS DynamoDB transactions with deletes or ETag conditions

A delete inside a transaction previously ignored its ETag, and failed ETag conditions could be reported as generic errors. Now the delete checks its ETag, and a failed condition returns an ETag mismatch (HTTP status 409 or gRPC code Aborted).

Evidence“After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.” dapr/dapr/releases/tag/v1.19.2 ↗
Show release-note lines
| AWS DynamoDB | A set or a delete with an ETag no longer matches an expired item. A `first-write` set succeeds on an expired item. A delete in a transaction checks its ETag. A failed condition in a transaction returns an ETag mismatch. |
github.com/dapr/dapr/releases/tag/v1.19.2

CockroachDB stored ETags now increment on sets without an ETag

AffectsCockroachDB state stores

When a set without an ETag targeted an existing key, the stored ETag used to stay unchanged, so an ETag read before the write still matched afterward. The stored ETag now increments after that set.

Show release-note lines
| CockroachDB | A set without an ETag increments the ETag of the stored row. A delete with an ETag no longer matches an expired row. |
github.com/dapr/dapr/releases/tag/v1.19.2

CockroachDB ETag deletes no longer match expired rows

AffectsCockroachDB state stores with TTL-enabled rows and ETag-based deletes

When a row’s TTL had passed but the store had not removed it, a delete with its ETag could succeed even though a read no longer returned the key. After the upgrade, the delete fails with an ETag mismatch (HTTP status 409 or gRPC code Aborted).

Evidence“After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.” dapr/dapr/releases/tag/v1.19.2 ↗
Show release-note lines
| CockroachDB | A set without an ETag increments the ETag of the stored row. A delete with an ETag no longer matches an expired row. |
github.com/dapr/dapr/releases/tag/v1.19.2

etcd ETag and first-write checks made atomic with writes

Affectsetcd set, delete, or transaction operations using ETags or first-write

If another write landed between the separate check and write, a set, delete, or transaction operation could be skipped while the request still reported success. Such requests now fail with an ETag mismatch: HTTP status 409 or gRPC code Aborted.

Show release-note lines
| etcd | Set, delete and transactions check ETags and `first-write` in the same etcd transaction as the write. A failed check applies nothing and returns an ETag mismatch. An ETag that is not a number returns an invalid ETag error. |
github.com/dapr/dapr/releases/tag/v1.19.2

In-memory state-store expired-key checks corrected

Affectsin-memory state-store ETag operations and first-write sets

When a key's TTL had passed but the store had not removed it, a set or delete with its ETag could succeed even though reads no longer returned the key; on some stores, first-write sets were rejected as if the key still existed. Now ETag requests against such keys fail with an ETag mismatch (HTTP status 409 or gRPC code Aborted), while first-write sets succeed.

Evidence“After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.” dapr/dapr/releases/tag/v1.19.2 ↗
Show release-note lines
| In-memory | An ETag no longer matches an expired key, and a `first-write` set succeeds on one. Operations in a transaction are checked in order, so each one sees the earlier ones. |
github.com/dapr/dapr/releases/tag/v1.19.2

MongoDB ETag deletes no longer match expired documents

AffectsMongoDB state stores using ETags for deletes

If a document's TTL had passed but the store had not removed it, a delete with its ETag could succeed even though reads no longer returned the key. After the upgrade, the delete fails with an ETag mismatch (409 over HTTP or Aborted over gRPC).

Evidence“After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.” dapr/dapr/releases/tag/v1.19.2 ↗
Show release-note lines
| MongoDB | A delete with an ETag no longer matches an expired document. A set with an ETag treats an expired document as missing. A transaction returns the error of a failed commit. |
github.com/dapr/dapr/releases/tag/v1.19.2

MongoDB ETag sets treat expired documents as missing

AffectsMongoDB sets with ETags

If a document's TTL had passed but the store had not removed it, a set could still succeed with its ETag even though a read no longer returned the key. Such requests now fail with an ETag mismatch (HTTP status 409 or gRPC code Aborted).

Evidence“After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.” dapr/dapr/releases/tag/v1.19.2 ↗
Show release-note lines
| MongoDB | A delete with an ETag no longer matches an expired document. A set with an ETag treats an expired document as missing. A transaction returns the error of a failed commit. |
github.com/dapr/dapr/releases/tag/v1.19.2

State-store ETag deletes no longer match expired rows

AffectsMySQL, Oracle Database, PostgreSQL, or SQLite state stores

A row whose TTL had passed but that the store had not removed could still be deleted with an ETag, even though reads no longer returned its key. Such deletes now fail with an ETag mismatch: HTTP status 409 or gRPC code Aborted.

Evidence“After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.” dapr/dapr/releases/tag/v1.19.2 ↗
Show release-note lines
| MySQL, Oracle Database, PostgreSQL, SQLite | A delete with an ETag no longer matches an expired row. |
github.com/dapr/dapr/releases/tag/v1.19.2

RavenDB transaction deletes now check ETags

AffectsRavenDB transactions with deletes carrying ETags

Previously, a delete inside a transaction ignored its ETag. After the upgrade, an ETag mismatch fails with HTTP status 409 or gRPC code Aborted.

Show release-note lines
| RavenDB | A `first-write` set without an ETag fails when the document exists and has not expired. A delete in a transaction checks its ETag. |
github.com/dapr/dapr/releases/tag/v1.19.2

Redis transaction writes are now all-or-none

AffectsRedis transactions using ETags or first-write

Before, a failed ETag check could still allow the transaction’s other operations to run. The transaction now checks all ETags and first-write options before writing, so a failed check prevents all its writes.

Evidence“After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.” dapr/dapr/releases/tag/v1.19.2 ↗
Show release-note lines
| Redis | A transaction runs as one script that checks every ETag and `first-write` option before it writes, so it applies all of its operations or none. A set applies its value and its TTL in the same script. A delete with an ETag that is not a number returns an invalid ETag error. |
github.com/dapr/dapr/releases/tag/v1.19.2

SQL Server expired-row ETag checks fixed

AffectsSQL Server state-store operations using ETags

When a row's TTL had passed but it had not yet been removed, a set or delete with a matching ETag could succeed even though a read no longer returned the key. Such requests now fail with an ETag mismatch: HTTP 409 or gRPC Aborted.

Evidence“After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.” dapr/dapr/releases/tag/v1.19.2 ↗
Show release-note lines
| SQL Server | A set or a delete with an ETag no longer matches an expired row. A `first-write` set succeeds on an expired row, and returns an ETag mismatch when the key exists. |
github.com/dapr/dapr/releases/tag/v1.19.2

Azure Cosmos DB transaction ETag mismatches return specific errors

AffectsAzure Cosmos DB transactions

Previously, an ETag mismatch inside a transaction returned a generic error, making it indistinguishable from other failures. It now returns HTTP 409 or gRPC Aborted.

Evidence“After the upgrade, requests that these stores accepted by mistake fail with an ETag mismatch: HTTP status `409`, or gRPC code `Aborted`.” dapr/dapr/releases/tag/v1.19.2 ↗
Show release-note lines
| Azure Cosmos DB | An ETag mismatch in a transaction returns an ETag mismatch error. A transaction that deletes a missing item no longer fails. |
github.com/dapr/dapr/releases/tag/v1.19.2

Important fixes11Silent failure1

  • Raw-payload publish tracing fixed
    AffectsRaw-payload publishes with rawPayload set to true using gRPC BulkPublishEvent or HTTP /v1.0-alpha1/publish/bulk and /v1.0/publish, with tracing across publisher and subscriber

    Previously, bulk publishes over gRPC or HTTP and single publishes over HTTP could start separate subscriber traces instead of continuing the publisher trace; HTTP bulk baggage could also be lost unless the pub/sub component implemented bulk publish natively. Each affected message now carries the publish trace context and baggage in its metadata, and bulk publishes start a producer span per entry.

    ## Raw payload publishes over HTTP and raw bulk publishes did not carry trace context
    ### Problem
    When an app published with `rawPayload` set to `true`, the sidecar did not add the trace context of the publish to the message for these calls:
    - Bulk publish over gRPC (`BulkPublishEvent`) and HTTP (`/v1.0-alpha1/publish/bulk`).
    - Single publish over HTTP (`/v1.0/publish`).
    The subscriber's sidecar started a new trace for each message instead of continuing the publisher's trace.
    Over HTTP bulk publish, baggage was also lost unless the pub/sub component implements bulk publish natively.
    ### Impact
    You were affected if you publish raw payloads with one of these calls and trace across the publisher and the subscriber.
    Each delivery appeared as a separate trace, not linked to the publish.
    Single raw publishes over gRPC and publishes with a cloud event envelope were not affected.
    ### Root Cause
    With a cloud event envelope, the sidecar writes the trace context into the envelope.
    A raw payload has no envelope, so the trace context has to go into the message metadata, where the subscriber's sidecar reads it.
    Only single publish over gRPC did that. The other calls added only the baggage.
    HTTP bulk publish added the baggage to the request metadata, and the sidecar's built-in bulk publisher does not pass request metadata on to each message.
    
    
    For raw payload publishes over gRPC and HTTP, single and bulk, the sidecar now adds the trace context and the baggage to the metadata of each message.
    Bulk publishes start one producer span per entry, as bulk publishes with a cloud event envelope already do.
    - [Raw payload publishes over HTTP and raw bulk publishes did not carry trace context](#raw-payload-publishes-over-http-and-raw-bulk-publishes-did-not-carry-trace-context)
    github.com/dapr/dapr/releases/tag/v1.19.2
  • HTTP and gRPC bulk publish metadata propagation fixedSilent failure
    Affectsbulk publish over HTTP or gRPC with request-level metadata

    Previously, entries without their own metadata map missed request-level keys such as ttlInSeconds and partitionKey; on components such as Redis, messages with only request-level ttlInSeconds could therefore never expire. Now request-level metadata is applied to every entry, while entry-level keys take precedence; request-level rawPayload is unaffected.

    ## Bulk publish ignored request-level metadata for entries without their own metadata
    ### Problem
    When publishing events in bulk, metadata set on the request, such as `ttlInSeconds` or `partitionKey`, was only applied to entries that also carried metadata of their own.
    Entries with no metadata were published without the request-level metadata.
    For example, publishing two entries with `ttlInSeconds=300` on the request, where only the first entry set its own `partitionKey`, produced a cloud event with an `expiration` field on the first entry and none on the second.
    ### Impact
    You were affected on Dapr 1.19.0 and 1.19.1, and on earlier releases, if you used the bulk publish API over HTTP or gRPC with request-level metadata.
    Most SDK bulk publish calls, such as `PublishEvents` in the Go SDK and `publish_events` in the Python SDK, build entries with no per-entry metadata, so for those callers request-level metadata had no effect at all.
    On components whose message TTL is handled by Dapr rather than natively, such as Redis, messages published with only a request-level `ttlInSeconds` never expired.
    Other request-level keys that a component reads per message, such as a partition key, were not applied either.
    The only workaround was to repeat the metadata on every entry.
    ### Root Cause
    The HTTP and gRPC bulk publish handlers merged request-level metadata into an entry only when the entry already had a metadata map.
    An entry with no metadata had none, so the merge was skipped and no request-level key reached it.
    The merge itself already handled an entry without metadata correctly; only the guard around it skipped the call.
    ### Solution
    Both handlers now merge request-level metadata into every entry.
    Entry-level keys keep precedence over request-level keys, matching the documented behavior of bulk publish and of the single publish API.
    `rawPayload` is still read from request-level metadata before the entries are processed and is unaffected.
    - [Bulk publish ignored request-level metadata for entries without their own metadata](#bulk-publish-ignored-request-level-metadata-for-entries-without-their-own-metadata)
    github.com/dapr/dapr/releases/tag/v1.19.2
  • MongoDB failed-commit error reporting fixed
    AffectsMongoDB transactions

    When a MongoDB transaction failed to commit, it reported success; it now returns the commit error.

    | MongoDB | A delete with an ETag no longer matches an expired document. A set with an ETag treats an expired document as missing. A transaction returns the error of a failed commit. |
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Sidecar connection pool keys connections by app and namespace
    AffectsmTLS-enabled apps calling actors or workflows on remote apps

    When an app called actors or workflows on a remote app and a pod reused another app’s IP, calls could use the previous app’s connection and fail with Unavailable or an unexpected SPIFFE ID handshake error. Now calls to a different app at that address use credentials for that app; idle connections there for other apps close when the new connection is dialed, while in-use connections finish.

    - [Actor and workflow calls kept failing after a pod IP was reused by a different app](#actor-and-workflow-calls-kept-failing-after-a-pod-ip-was-reused-by-a-different-app)
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Corrected loading of hot-reloaded state stores marked actorStateStore false
    AffectsHot reload with actors enabled and state stores configured with actorStateStore set to false

    Previously, adding or changing one of these stores while the sidecar was running caused it to be skipped when an actor state store was already loaded, so calls failed until restart; this also happened when false came from an environment variable or secret. The store is now loaded and available to the state API when the state processor would not designate it as the actor state store.

    - [A state store with actorStateStore set to false was not hot reloaded](#a-state-store-with-actorstatestore-set-to-false-was-not-hot-reloaded)
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Sidecar connection pooling now distinguishes apps
    AffectsmTLS-enabled calls to actors or workflows on a remote app

    When Kubernetes reused a stopped pod's IP for a different app, the sidecar kept using the previous app's connection, causing unexpected SPIFFE ID handshakes and Unavailable actor or workflow calls. It now dials with the new app's credentials and closes idle connections for other apps at that address, while connections in use are left to finish.

    ## Actor and workflow calls kept failing after a pod IP was reused by a different app
    ### Problem
    The sidecar keeps one gRPC connection per remote address for calls to other sidecars, such as actor invocation and workflow calls between apps.
    The mTLS credentials of a connection pin the namespace and app ID of the peer it was created for, and gRPC reuses them every time the connection reconnects.
    The connection pool was keyed by address only.
    When Kubernetes gave the IP of a stopped pod to a pod of a different app, the sidecar kept using the connection created for the previous app.
    Every handshake failed with `unexpected SPIFFE ID`, and every actor or workflow call to the new app on that address failed with `Unavailable`.
    ### Impact
    You were affected if mTLS is enabled, your apps call actors or workflows on a remote app, and the IP of a pod was reused by a pod of a different app.
    Calls from a sidecar to that address kept failing until the sidecar stopped calling it for 3 minutes (`DAPR_GRPC_MAX_CONN_IDLE`) or the target pod got a new IP.
    With steady traffic, that did not happen. Calls to other pods of the same app were not affected.
    Deleting the pod that received the reused IP recovered it.
    ### Root Cause
    The pool looked up an existing connection by address, and the identity the connection expects was not part of the lookup.
    Before Dapr 1.15 the actor call path closed the connection when a call failed with `Unavailable`, which hid the problem.
    Since 1.15 it does not, and nothing else closes a connection that is in use.
    Service invocation and the gRPC proxy still close the connection on `Unavailable`, so they recovered.
    ### Solution
    The connection pool is now keyed by address, namespace and app ID.
    A sidecar that finds a different app at an address it has used before dials a new connection with the credentials for that app.
    Connections to the same address, namespace and app ID are still shared.
    When a sidecar dials a new connection to an address, it also closes the idle connections it holds there for other apps, which can no longer succeed. Connections that are in use are left to finish.
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Placement out-of-sequence acknowledgement hang fixed
    Affectsapps declaring actor types without an actor state store

    When such an app’s sidecar connected to Placement while only one other actor sidecar was connected in the namespace, Placement could wait indefinitely for an out-of-sequence unlock response; new sidecars did not become ready and actor placement stopped changing. Placement now counts acknowledgements for sidecar-only table copies only when they match the current update step.

    ## Actor sidecars stopped becoming ready after a sidecar without an actor state store joined
    ### Problem
    The Placement service could stop sending placement tables in a namespace.
    After that, every new sidecar in the namespace waited for its table and never became ready, and actor placement in the namespace stopped changing.
    The Placement service did not recover on its own.
    ### Impact
    You were affected if an app declares actor types but has no actor state store, and its sidecar connects to Placement when only one other sidecar with actors is connected in the namespace.
    New sidecars in that namespace did not become ready until the Placement leader restarted.
    ### Root Cause
    A sidecar that declares actor types but has no actor state store reports its host to Placement twice when it connects.
    Placement answers each report with a copy of the placement table sent to that sidecar only, and ignores the sidecar's acknowledgements of that copy.
    After the second copy, Placement counted the sidecar's acknowledgements as part of a namespace-wide update that was not running.
    With two sidecars in the namespace, that was enough to finish the phantom update, and Placement asked the other sidecar to unlock with no timeout set.
    The other sidecar ignored that request because it was out of sequence, and Placement waited for its answer indefinitely.
    ### Solution
    Placement now counts an acknowledgement only when it is for the current step of the update.
    - [Actor sidecars stopped becoming ready after a sidecar without an actor state store joined](#actor-sidecars-stopped-becoming-ready-after-a-sidecar-without-an-actor-state-store-joined)
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Scheduler releases concurrency gates before retrying queued work
    AffectsDapr 1.19.0 or 1.19.1 setups with workflowConcurrencyLimits and globalMaxConcurrentWorkflowInvocations, or activityConcurrencyLimits and globalMaxConcurrentActivityInvocations

    When both matching per-name and global limits were set, work waiting for a slot could stay queued after an instance completed until an unrelated workflow or activity of the same type completed, leaving work far below its configured limit.

    ## Workflows and activities with per-name concurrency limits stalled in the Scheduler
    ### Problem
    When a workflow or activity name had a per-name concurrency limit and the matching global limit was also set, work waiting for a free slot was not started when a running instance completed.
    It stayed queued until some unrelated workflow or activity of the same type completed.
    ### Impact
    You were affected on Dapr 1.19.0 and 1.19.1 if, in the `workflow` section of the Dapr Configuration, you set a per-name limit together with the global limit of the same kind:
    `workflowConcurrencyLimits` with `globalMaxConcurrentWorkflowInvocations`, or `activityConcurrencyLimits` with `globalMaxConcurrentActivityInvocations`.
    Per-name limits set without the matching global limit were not affected.
    Workflows and activities with those names ran far below their configured limit. With a per-name limit of 1, only 1 of 10 queued activities ran in about 45 seconds.
    ### Root Cause
    With both limits set, a workflow or activity holds two concurrency gates in the Scheduler: one for its type (the global limit) and one for its name (the per-name limit). Waiting work queues on the type gate.
    When an instance completed, the Scheduler released the type gate and tried to start waiting work before it released the name gate. That attempt failed because the name gate was still held, and the work was queued again.
    Releasing the name gate a moment later did not retry it, so the work waited for the next unrelated release.
    ### Solution
    The Scheduler releases all the gates held by a completed workflow or activity before it tries to start waiting work.
    - [Workflows and activities with per-name concurrency limits stalled in the Scheduler](#workflows-and-activities-with-per-name-concurrency-limits-stalled-in-the-scheduler)
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Parent sidecars accept dispatched cross-app workflow and activity results
    Affectsapps using WorkflowAccessPolicy with cross-app child workflows or activity results

    Previously, the parent’s sidecar treated child-workflow completions and cross-app activity results as malformed, so child workflows stayed RUNNING indefinitely while the child retried. After upgrading the parent sidecar, a child’s next retry delivers the result; results are accepted only from the app the task was dispatched to, and attestation is still checked when workflow history signing is on.

    ## Cross-app child workflows never completed when the parent app had a workflow access policy
    ### Problem
    When a workflow called a child workflow on another app, and a `WorkflowAccessPolicy` applied to the parent workflow's app, the parent never received the child's result.
    The child completed, but the parent stayed `RUNNING` indefinitely, and the child kept re-sending its result on a reminder.
    The parent's sidecar rejected every delivery with `access denied by workflow access policy: malformed request for method 'AddWorkflowEvent'`.
    ### Impact
    You were affected on Dapr 1.19.0 and 1.19.1 if a `WorkflowAccessPolicy` applied to an app and a workflow of that app called a child workflow on another app.
    Every such parent workflow waited for its child indefinitely.
    No rule in the policy could let the result through, so removing the policy from the parent app was the only workaround.
    Workflows that called activities on another app were not blocked. The activity result was rejected in the same way, but then reached the parent through the activity result reminder. Each rejection still logged a warning and incremented `dapr_runtime_workflow_acl_action_denied_total`.
    ### Root Cause
    The parent's sidecar checks every call from another app against its workflow access policy.
    It works out the operation from the type of history event the call carries, and it only recognised terminate, raise event, pause and resume.
    A child workflow's completion or an activity's result is none of these, so the check treated the call as malformed and denied it before evaluating any rule.
    ### Solution
    The parent's sidecar no longer evaluates a child workflow's completion or an activity's result against the policy rules.
    These are replies to tasks the parent workflow dispatched, not operations another app performs on it.
    Instead, the parent accepts a result from another app only when the task was dispatched to that app, and denies it from any other app.
    The parent still verifies the result's attestation when workflow history signing is on.
    Only the sidecar of the parent's app needs the upgrade. After it, the child's next retry delivers the result and stuck parent workflows continue on their own.
    - [Cross-app child workflows never completed when the parent app had a workflow access policy](#cross-app-child-workflows-never-completed-when-the-parent-app-had-a-workflow-access-policy)
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Hot reload handling of actorStateStore: false fixed
    Affectsstate stores with actorStateStore set to false

    Previously, adding or changing one while another actor state store was loaded caused hot reload to skip it, leaving it unavailable to the state API and causing calls to fail until daprd was restarted. Hot reload now uses the state processor’s evaluation, including duplicate-entry precedence and {appID} expansion; it resolves environment-variable and secret values on a copy, while unknown values still mark the store and components not scoped to the app are not resolved.

    A state store component with the `actorStateStore` metadata set to `"false"` was never loaded when it was added or updated through hot reload while an actor state store was already loaded.
    Daprd logged `Skipping hot reload of <store>: <actor store> is already the actor state store, only one actor state store is allowed`, and the store stayed unavailable to the state API.
    The same happened when the value came from an environment variable or a secret that resolves to `"false"`.
    You were affected if hot reload is enabled, actors are enabled, and you added or changed a state store component that sets `actorStateStore` to false while the sidecar was running.
    Calls to that state store failed until daprd was restarted.
    Stores that omit the `actorStateStore` metadata were not affected.
    To keep a second actor state store from being loaded, the hot reload reconciler skips a state store that is marked as the actor state store.
    It decided that from the presence of the `actorStateStore` metadata alone, while the state processor makes a store the actor state store only when the value is true.
    The reconciler now builds the metadata of the component as the state processor does, and applies the state processor's own check to it, including which of duplicate entries wins and how placeholders such as `{appID}` expand.
    When the `actorStateStore` value comes from an environment variable or a secret, the reconciler resolves it on a copy of the component first.
    A store is skipped only when the state processor would make it the actor state store.
    A value that cannot be known, because its secret store is not loaded, its secret read fails or its metadata cannot be built, still marks the store, as before.
    Components that are not scoped to the app are not resolved.
    github.com/dapr/dapr/releases/tag/v1.19.2
  • In-memory state-store transaction operations checked in order
    Affectsin-memory state-store transactions containing multiple operations

    Each operation sees the effects of earlier operations in the same transaction.

    | In-memory | An ETag no longer matches an expired key, and a `first-write` set succeeds on one. Operations in a transaction are checked in order, so each one sees the earlier ones. |
    github.com/dapr/dapr/releases/tag/v1.19.2

Enhancements1

  • Force purge for inconsistent workflow instances

    To use --force flag

    Force purging a workflow instance failed when the instance metadata declared more inbox or history entries than exist in the state store.
    The request returned an error such as `inbox key 'inbox-000000' declared in metadata (inboxLength=2) but missing from state store`, and all of the instance's state and reminders were left in place.
    You were affected if you have workflow instances that were saved with an inbox count larger than the number of stored inbox entries.
    An inbox accounting bug in earlier releases, fixed by [#10155](https://github.com/dapr/dapr/pull/10155), could save an instance in this state, including instances created on Dapr 1.17.
    Since Dapr 1.18.0 these instances cannot be loaded, so get, terminate, purge and force purge all failed with the same error, and the instance's reminders kept retrying.
    The only way to remove such an instance was to delete its keys from the state store by hand.
    Force purge loaded the instance with the same strict check as every other workflow operation, which rejects state whose metadata declares an entry that is missing.
    It also built its list of keys to delete from the entries it had loaded, not from the counts declared in the metadata.
    Force purge now loads the entries that exist and skips the ones that are confirmed missing.
    It deletes every key the metadata declares, along with the instance's reminders.
    All other workflow operations keep the strict check and still fail for these instances.
    To remove an affected instance, run `dapr workflow purge <instance-id> --force`.
    - [Workflow force purge failed on instances with missing inbox or history entries](#workflow-force-purge-failed-on-instances-with-missing-inbox-or-history-entries)
    github.com/dapr/dapr/releases/tag/v1.19.2

Dependency updates1

  • github.com/andybalholm/brotli upgraded to v1.2.7

    The earlier decompressor did not limit the memory it allocated for each meta-block. Version v1.2.7 fixes this issue.

    CVE-2026-111497GHSA-c9gr-gmg4-2vqvGO-2026-6888
    ## Security: brotli denial of service
    ### Problem
    An indirect dependency of Dapr, `github.com/andybalholm/brotli`, had a vulnerability in v1.2.1:
    - [CVE-2026-111497](https://github.com/andybalholm/brotli/security/advisories/GHSA-c9gr-gmg4-2vqv) ([GO-2026-6888](https://pkg.go.dev/vuln/GO-2026-6888)): the brotli decompressor did not limit the memory that it allocates for each meta-block. A small crafted brotli stream can make it allocate hundreds of megabytes for each kilobyte of input. This causes a denial of service.
    ### Impact
    Dapr uses brotli only through the Meilisearch search component (`search.meilisearch`) and its `meilisearch-go` client.
    That client decompresses brotli data only when the code that creates the client sets a content encoding.
    The Dapr Meilisearch component does not set a content encoding, so Dapr does not decompress brotli data.
    Vulnerability scanners and `govulncheck` report this vulnerability for Dapr 1.19.0 and 1.19.1, because both releases include brotli v1.2.1.
    ### Root Cause
    Dapr pinned brotli at v1.2.1. brotli v1.2.7 fixes CVE-2026-111497.
    ### Solution
    This release upgrades `github.com/andybalholm/brotli` from v1.2.1 to v1.2.7.
    - [Security: Fixes brotli denial of service - CVE-2026-111497](#security-brotli-denial-of-service)
    github.com/dapr/dapr/releases/tag/v1.19.2
Other changes13
  • AWS DynamoDB first-write sets on expired items now succeed
    | AWS DynamoDB | A set or a delete with an ETag no longer matches an expired item. A `first-write` set succeeds on an expired item. A delete in a transaction checks its ETag. A failed condition in a transaction returns an ETag mismatch. |
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Azure Cosmos DB missing-item deletion failure fixed
    | Azure Cosmos DB | An ETag mismatch in a transaction returns an ETag mismatch error. A transaction that deletes a missing item no longer fails. |
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Nonnumeric etcd ETags return an invalid ETag error
    | etcd | Set, delete and transactions check ETags and `first-write` in the same etcd transaction as the write. A failed check applies nothing and returns an ETag mismatch. An ETag that is not a number returns an invalid ETag error. |
    github.com/dapr/dapr/releases/tag/v1.19.2
  • RavenDB first-write set failure
    | RavenDB | A `first-write` set without an ETag fails when the document exists and has not expired. A delete in a transaction checks its ETag. |
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Redis state-store sets apply values and TTLs in one script
    | Redis | A transaction runs as one script that checks every ETag and `first-write` option before it writes, so it applies all of its operations or none. A set applies its value and its TTL in the same script. A delete with an ETag that is not a number returns an invalid ETag error. |
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Redis deletes with nonnumeric ETags return an invalid ETag error
    | Redis | A transaction runs as one script that checks every ETag and `first-write` option before it writes, so it applies all of its operations or none. A set applies its value and its TTL in the same script. A delete with an ETag that is not a number returns an invalid ETag error. |
    github.com/dapr/dapr/releases/tag/v1.19.2
  • SQL Server first-write sets distinguish expired and existing keys
    | SQL Server | A set or a delete with an ETag no longer matches an expired row. A `first-write` set succeeds on an expired row, and returns an ETag mismatch when the key exists. |
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Production-use warning removed for non-Cluster Redis deployments
    For other Redis deployments, the component no longer logs that Redis should not be used as an actor state store in production.
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Per-key ETag handling in AWS DynamoDB, etcd, and RavenDB transactions
    AWS DynamoDB, etcd and RavenDB accept one operation for each key in a transaction.
    For several operations on one key, these components send the last operation with the ETag or `first-write` option of the first one.
    A later operation on that key that carries an ETag, or a `first-write` set after a set, fails with an ETag mismatch.
    github.com/dapr/dapr/releases/tag/v1.19.2
  • ETag mismatch in delete-then-set transactions
    The exception is a transaction that deletes a key and then sets the same key with an ETag: on Azure Cosmos DB, MongoDB and Redis that set fails with an ETag mismatch, because the version the ETag refers to is gone.
    github.com/dapr/dapr/releases/tag/v1.19.2
  • In-memory state store skips ETag pass for transactions without ETag operations
    The in-memory store skips the ETag pass for a transaction in which no operation has an ETag or `first-write`.
    github.com/dapr/dapr/releases/tag/v1.19.2
  • MongoDB ETag deletes use a single command
    On MongoDB 4.4 and later, a delete with an ETag is a single delete command.
    github.com/dapr/dapr/releases/tag/v1.19.2
  • Redis state store sends scripts with EVALSHA
    The Redis component sends its script by hash (`EVALSHA`), and sends the script body only when the server has not cached it.
    github.com/dapr/dapr/releases/tag/v1.19.2

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