perf: pipeline redis set_state writes, cache required-state classes

[Alek99]

All Submissions:

• Have you followed the guidelines stated in CONTRIBUTING.md file?
• Have you checked to ensure there aren't any other open Pull Requests for the desired changed?

Type of change

• Bug fix (non-breaking change which fixes an issue)

Changes To Core Features:

• Have you added an explanation of what your changes do and why you'd like us to include them?
• Have you written new tests for your core changes, as applicable?

StateManagerRedis.set_state recursed over the substate tree spawning a task per substate; every recursive call re-GETed the same lock key and re-PTTLed it, and each touched state got its own unpipelined SET — roughly 2N+1 redis round trips per event flush for N states. get_state already pipelines its reads; set_state now does the same for writes (ENG-10097):

• Verify the lock once, write once: the tree is walked iteratively, the lock GET + PTTL happen a single time, and all touched states' payloads go out in one pipeline. 3 round trips per flush regardless of tree size.
• Off-loop pickling: states whose previous payload exceeded 64 KiB are serialized via asyncio.to_thread instead of stalling the event loop (safe: the token's lock is held, so nothing mutates the tree mid-pickle — the old code awaited between pickles too).
• Cached _get_required_state_classes: the recursive class-level computation ran on every get_state. It's now an lru_cached module function keyed on (target class, registration context, state hierarchy generation); BaseState.__init_subclass__ and reload_state_module bump the generation, so dynamically created classes and hot reload invalidate cleanly (including same-name class redefinition, where registry sizes don't change).
• _was_touched reset after write (mirrors the disk manager's existing get_and_reset_touched_state): previously the flag was never cleared, so a once-touched state kept alive by the oplock cache was re-pickled and re-SET on every subsequent flush. Reset only happens after a successful pipeline execute, so failed writes retry.

Round trips per event flush (modeled on the exact before/after command flows; "3" = lock GET + PTTL + one pipelined write):

state tree	before	after	worst-case serialized latency @ 0.25 ms RTT
root + 3 substates	12	3	3.00 ms → 0.75 ms (4x)
root + 9 substates	30	3	7.50 ms → 0.75 ms (10x)
3 levels × 3 wide (13 states)	39	3	9.75 ms → 0.75 ms (13x)

New unit tests (run against both mock and real redis in CI): test_set_state_verifies_lock_once_and_pipelines_writes counts actual GET/PTTL commands during a 3-substate modify (asserts exactly one of each); test_set_state_resets_touched_flag asserts a second flush of an unchanged instance creates no write pipeline at all; test_set_state_offloads_large_pickles asserts the to_thread path engages above the threshold; test_required_state_classes_cache_invalidation asserts a subclass defined after cache warm-up appears in the cached result via the generation bump. Existing modify_state/oplock/expiration tests cover end-to-end behavior.

Linear: ENG-10097

🤖 Generated with Claude Code

https://claude.ai/code/session_01Sns7EuBPYvfGCxRSRZ1bUx

---

Generated by Claude Code

[greptile-apps]

Greptile Summary

This PR speeds up Redis state persistence and required-state lookup. The main changes are:

• Batched Redis set_state writes into one pipeline.
• Single lock verification per flush.
• Large-state serialization routed through a thread path.
• Required-state class discovery cached with hierarchy invalidation.
• Tests added for Redis write batching, touched-state reset, and cache refresh.

Confidence Score: 4/5

This is close, but the Redis serialization race should be fixed before merging.

• The batched write path keeps the prior live-object thread handoff.
• A concurrent state change can be missed after _was_touched is cleared.
• The failure affects persisted Redis state for large previously serialized states.

Files Needing Attention: reflex/istate/manager/redis.py

Important Files Changed

Filename	Overview
reflex/istate/manager/redis.py	Batches Redis state writes and adds required-state caching, but the large-state serialization path can still persist stale state.
reflex/state.py	Adds a hierarchy generation counter and invalidates it when state classes or modules change.
tests/units/istate/manager/test_redis.py	Adds Redis manager coverage for lock checks, pipelined writes, touched-flag reset, large serialization, and cache invalidation.
tests/units/mock_redis.py	Updates mock Redis GETDEL behavior so command-count tests measure the intended calls.
tests/units/test_state.py	Updates the expected warning count for the new single-flush Redis write path.
news/6745.performance.md	Documents the Redis state manager performance change.

_{Reviews (3): Last reviewed commit: "Appease pyright in redis manager tests" | Re-trigger Greptile}

[codspeed-hq]

Merging this PR will not alter performance

✅ 27 untouched benchmarks
⏩ 8 skipped benchmarks¹

---

_{Comparing claude/reflex-perf-optimizations-21kg8y-redis (b7ce2f3) with claude/reflex-perf-optimizations-21kg8y-socket (034abea)}

Footnotes

1. 8 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 9cd59d2f22

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[masenf]

the _was_touched flag was already being reset by virtue of BaseState.__setstate__ popping the flag out of the payload that gets saved in the pickle, so this is just added overhead now.

[Alek99]

Root cause of the unit-tests failures (4× test_app_modify_state_clean, all Python versions):

The unit-tests job exports REFLEX_REDIS_URL, so StateManager.create() returns StateManagerRedis. This test's assert sub._was_touched / assert root_state._was_touched (after the modify_state context exits) now fail because the pipelined set_state in this PR resets _was_touched = False after a successful write — which is the intended fix (so an oplock-cached state isn't re-pickled/re-SET on every flush), and matches the disk manager's existing get_and_reset_touched_state.

So _was_touched no longer survives persistence for the redis manager. The _was_touched assertions in test_app_modify_state_clean need to reflect that — e.g. capture the flag inside the async with block before the write, or assert on the emitted delta (which the frontend branch already does) rather than the post-write flag. Flagging rather than pushing since the branch was force-pushed into the consolidated stack and this same test file was just touched in 66c2c99f; happy to push a targeted fix if you'd like me to.

---

Generated by Claude Code

[greptile-apps]

Live serialization race When a previously large state is flushed, this path still sends the mutable substate object to a worker thread and yields the event loop while pickle reads it. A background task or overlapping flush can mutate the same state tree during that window, so Redis can receive a stale snapshot; after the pipeline succeeds, _was_touched is cleared and the interleaved change may not be written by the next flush. This needs a fix that avoids yielding while serializing the live object, or serializes from a stable snapshot that cannot change mid-pickle.