Reliable Redis setup (persistence enforced)

[nahimterrazas]

ship a simple Redis config example with persistence turned on, add a health check, and make the app shout/fail if Redis is down or running without persistence. Include a short “how to set up Redis persistence” doc.

AC:
by default the app points to a persistent Redis;
on startup it refuses to run if persistence is off or Redis is unreachable;
add docs to explains the settings and how to verify them.

[coderabbitai]

📝 CodeRabbit Plan Mode

Generate an implementation plan and prompts that you can use with your favorite coding agent.

✅ Successfully generated implementation plan.

💡 Use @coderabbitai <feedback> to replan

Examples

• Example 1
• Example 2

---

🔗 Similar Issues

Related Issues

• Config store with seeding #267

👤 Suggested Assignees

• nahimterrazas

---

🧪 Issue enrichment is currently in open beta.

You can configure auto-planning by selecting labels in the issue_enrichment configuration.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord or schedule a call!

[coderabbitai]

Coding Plan

Approach

Add Redis persistence enforcement to the application by implementing a startup health check that validates Redis is both reachable and configured with persistence (AOF or RDB), refusing to start if either condition fails. Include updated configuration examples and documentation.

Observations

The application uses a factory registry pattern for dependency injection, with Redis storage implemented in crates/solver-storage/src/implementations/redis.rs using the redis crate's async ConnectionManager. The main startup sequence in crates/solver-service/src/main.rs loads configuration, builds the solver engine via build_solver_from_config(), and optionally starts an HTTP API server. Redis configuration is already present in config/demo.toml but absent from production configs. No startup health checks currently exist.

Assumptions

Assumption 1: What constitutes "persistence enabled" for enforcement purposes?

Options Considered:

• Require both AOF and RDB to be enabled
• Require at least one of AOF or RDB to be enabled (either is acceptable)

Chosen Option: 2

Rationale: Accept either mechanism since both provide persistence guarantees, and many production setups use only one.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Redis Persistence Check Implementation

Add the capability to verify Redis persistence status within the storage layer, along with configuration support for enforcement behavior.

Task 1: Add Persistence Check Configuration

Add a new configuration field to control persistence enforcement behavior.

• Add require_persistence boolean field to Redis storage configuration in crates/solver-storage/src/implementations/redis.rs config struct (default: true)
• Update configuration parsing to handle the new field alongside existing Redis settings
• Follow the existing pattern used for other optional fields like connection_timeout_ms

Task 2: Implement Persistence Status Check Function

Create a function that queries Redis to determine if persistence is enabled.

• Add an async function check_persistence_enabled() to the Redis storage implementation that:
  • Executes CONFIG GET appendonly to check AOF status (value "yes" means enabled)
  • Executes CONFIG GET save to check RDB status (non-empty value means snapshots configured)
  • Returns Ok(true) if either AOF or RDB is enabled, Ok(false) if neither
• Handle connection errors by propagating them with descriptive context
• Place this function within crates/solver-storage/src/implementations/redis.rs as a method on RedisStorage

Task 3: Add Public Validation Entry Point

Expose a validation function that combines connectivity and persistence checks.

• Add a public async method validate_redis_health() to RedisStorage that:
  • Attempts to establish connection (verifies Redis is reachable)
  • If require_persistence is true, calls check_persistence_enabled() and returns error if persistence is disabled
  • Returns a structured result indicating success or the specific failure reason
• Define appropriate error types or messages that distinguish between "unreachable" and "persistence not enabled"

🤖 Prompt for AI agents

Implement Redis persistence validation in the storage layer.

Add `require_persistence` boolean field (default `true`) to the Redis storage
config struct in `crates/solver-storage/src/implementations/redis.rs`.

Create async method `check_persistence_enabled()` on `RedisStorage` that:
- Executes `CONFIG GET appendonly` to check AOF status
- Executes `CONFIG GET save` to check RDB status
- Returns `Ok(true)` if either is enabled, `Ok(false)` if neither
- Propagates connection errors with context

Add public async method `validate_redis_health()` to `RedisStorage` that:
- Verifies Redis connectivity
- Calls `check_persistence_enabled()` if `require_persistence` is true
- Returns structured result distinguishing between connectivity and persistence
failures

Phase 2: Startup Validation Integration

Integrate the persistence check into the application startup flow to enforce the health check requirement.

Task 1: Add Storage Validation to Factory Registry

Extend the storage creation flow to perform validation when Redis is selected.

• Modify the Redis storage factory function in crates/solver-service/src/factory_registry.rs to call validate_redis_health() after creating the storage instance
• Ensure validation runs before the storage instance is returned for use
• On validation failure, return an error that propagates up to the main startup sequence

Task 2: Enhance Startup Error Handling

Ensure startup failures produce clear, actionable error messages.

• Update crates/solver-service/src/main.rs to handle storage validation errors with specific messaging
• Error messages should clearly state whether the issue is connectivity ("Redis unreachable") or configuration ("Redis persistence not enabled")
• Include guidance in the error output directing users to documentation (e.g., "See docs/redis-persistence.md for setup instructions")

🤖 Prompt for AI agents

Integrate Redis validation into the application startup flow.

Modify the Redis storage factory function in
`crates/solver-service/src/factory_registry.rs` to call
`validate_redis_health()` after creating the storage instance but before
returning it. Propagate validation failures as errors.

Update `crates/solver-service/src/main.rs` to handle storage validation errors
with clear messaging:
- Distinguish between connectivity failures ("Redis unreachable") and
persistence failures ("Redis persistence not enabled")
- Include reference to documentation ("See docs/redis-persistence.md for setup
instructions")

Phase 3: Configuration and Documentation

Update configuration files to use Redis by default in production environments and provide comprehensive setup documentation.

Task 1: Update Production Configuration Files

Configure mainnet and testnet environments to use Redis with persistence enforcement.

• Add [storage.implementations.redis] section to config/mainnet.toml with:
  • Redis URL pointing to localhost default
  • require_persistence = true
  • Appropriate TTL values matching the demo.toml pattern
• Add equivalent Redis configuration to config/testnet.toml
• Update the [storage] section in both files to set primary = "redis"

Task 2: Update Demo Configuration

Ensure demo configuration includes the new persistence enforcement setting.

• Add require_persistence = true to the existing Redis configuration in config/demo.toml
• Add a comment explaining the setting and noting it can be set to false for local development without persistent Redis

Task 3: Create Redis Persistence Documentation

Write documentation explaining Redis persistence setup and verification.

• Create docs/redis-persistence.md covering:
  • Why persistence is required (data durability for orders, intents, etc.)
  • How to enable AOF persistence (appendonly yes in redis.conf)
  • How to enable RDB persistence (save directives in redis.conf)
  • How to verify persistence is enabled using redis-cli CONFIG GET appendonly and CONFIG GET save
  • Configuration options: explain require_persistence field and when to disable it (development only)
  • Troubleshooting common startup failures
• Keep documentation concise and focused on the minimal steps needed for production setup

🤖 Prompt for AI agents

Update configuration files and create documentation for Redis persistence.

Add Redis configuration to `config/mainnet.toml` and `config/testnet.toml`:
- Add `[storage.implementations.redis]` section with localhost URL,
`require_persistence = true`, and TTL values matching demo.toml pattern
- Set `primary = "redis"` in the `[storage]` section

Update `config/demo.toml` to add `require_persistence = true` with a comment
explaining it can be disabled for local development.

Create `docs/redis-persistence.md` covering:
- Why persistence is required
- How to enable AOF and RDB persistence
- How to verify persistence using redis-cli
- The `require_persistence` configuration option
- Troubleshooting common failures

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement Redis persistence validation in the storage layer.

Add `require_persistence` boolean field (default `true`) to the Redis storage
config struct in `crates/solver-storage/src/implementations/redis.rs`.

Create async method `check_persistence_enabled()` on `RedisStorage` that:
- Executes `CONFIG GET appendonly` to check AOF status
- Executes `CONFIG GET save` to check RDB status
- Returns `Ok(true)` if either is enabled, `Ok(false)` if neither
- Propagates connection errors with context

Add public async method `validate_redis_health()` to `RedisStorage` that:
- Verifies Redis connectivity
- Calls `check_persistence_enabled()` if `require_persistence` is true
- Returns structured result distinguishing between connectivity and persistence
failures
===============================================================================

Task: 2

Integrate Redis validation into the application startup flow.

Modify the Redis storage factory function in
`crates/solver-service/src/factory_registry.rs` to call
`validate_redis_health()` after creating the storage instance but before
returning it. Propagate validation failures as errors.

Update `crates/solver-service/src/main.rs` to handle storage validation errors
with clear messaging:
- Distinguish between connectivity failures ("Redis unreachable") and
persistence failures ("Redis persistence not enabled")
- Include reference to documentation ("See docs/redis-persistence.md for setup
instructions")
===============================================================================

Task: 3

Update configuration files and create documentation for Redis persistence.

Add Redis configuration to `config/mainnet.toml` and `config/testnet.toml`:
- Add `[storage.implementations.redis]` section with localhost URL,
`require_persistence = true`, and TTL values matching demo.toml pattern
- Set `primary = "redis"` in the `[storage]` section

Update `config/demo.toml` to add `require_persistence = true` with a comment
explaining it can be disabled for local development.

Create `docs/redis-persistence.md` covering:
- Why persistence is required
- How to enable AOF and RDB persistence
- How to verify persistence using redis-cli
- The `require_persistence` configuration option
- Troubleshooting common failures

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For assumption 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!