Struct RustvelloBuilder 

pub struct RustvelloBuilder { /* private fields */ }

Fluent builder for constructing a [RustvelloApp].

Provides an ergonomic API for configuring backends, loading settings from environment variables or TOML files, and applying dev-mode presets.

Priority order (highest wins)

1. Programmatic — explicit builder method calls
2. Environment variables — always read automatically
3. Config file — via from_file()
4. pyproject.toml — [tool.rustvello.app]
5. Defaults

Examples

use rustvello::prelude::*;

// Minimal in-memory defaults
let app = Rustvello::builder()
    .app_id("my-app")
    .build().await?;

Implementations

impl RustvelloBuilder

pub async fn build(self) -> RustvelloResult<RustvelloApp>

Consume the builder and produce a RustvelloApp.

Establishes all backend connections (database, Redis, etc.) that were configured via preset methods like .sqlite(), .redis(), or .postgres().

If no backends were explicitly provided, falls back to:

• In-memory backends (when the mem feature is enabled)
• Error otherwise

If auto_discover_tasks() was called, all tasks registered via #[rustvello::task] are automatically added to the registry. Additionally, any task modules added via task_module() are registered.

impl RustvelloBuilder

pub fn memory(self) -> Self

Available on crate feature mem only.

Use all in-memory backends (suitable for testing and development).

No connections are established — backends are created during build().

pub fn sqlite(self, path: &str, app_id: &str) -> Self

Available on crate feature sqlite only.

Use all SQLite backends with the given database path.

The database file is opened during build(), not here.

pub fn redis(self, uri: &str, app_id: &str) -> Self

Available on crate feature redis only.

Use all Redis backends with the given connection URI.

The connection pool is created during build(), not here.

Examples

let app = Rustvello::builder()
    .redis("redis://127.0.0.1/", "my_app")
    .build().await?;

pub fn mongodb(self, uri: &str, db_name: &str, app_id: &str) -> Self

Available on crate feature mongodb only.

Use all MongoDB backends with the given connection URI and database name.

The connection pool is created during build(), not here.

Examples

let app = Rustvello::builder()
    .mongodb("mongodb://localhost:27017", "rustvello_db", "my_app")
    .build().await?;

pub fn rabbitmq(self, uri: &str, prefix: &str) -> Self

Available on crate feature rabbitmq only.

Use a RabbitMQ broker with the given AMQP URI and queue prefix.

Only sets the broker — orchestrator, state backend, client data store, and trigger store must be provided separately (e.g. via .redis() or .sqlite()). This matches the Python pynenc_rabbitmq plugin which only provides a broker implementation.

The connection is established during build(), not here.

Examples

let app = Rustvello::builder()
    .rabbitmq("amqp://localhost:5672", "myapp")
    .redis("redis://127.0.0.1/", "my_app")
    .build().await?;

pub fn postgres(self, connection_string: &str, app_id: &str) -> Self

Available on crate feature postgres only.

Use all PostgreSQL backends with the given connection string.

The connection pool is created during build(), not here.

Examples

let app = Rustvello::builder()
    .postgres("postgresql://user:pass@localhost/mydb", "my_app")
    .build().await?;

pub fn postgres_tls(self, connection_string: &str, app_id: &str) -> Self

Available on crate features postgres and tls only.

Use all PostgreSQL backends with TLS encryption.

Requires both the postgres and tls features.

pub fn mongo3(self, uri: &str, db_name: &str, app_id: &str) -> Self

Available on crate feature mongodb3 only.

Use all MongoDB 3.6+ backends with the given connection URI and database name.

The connection pool is created during build(), not here.

Examples

let app = Rustvello::builder()
    .mongo3("mongodb://localhost:27017", "rustvello_db", "my_app")
    .build().await?;

impl RustvelloBuilder

pub fn app_id(self, id: impl Into<String>) -> Self

Set the application identifier.

pub fn dev_mode(self, enabled: bool) -> Self

Enable or disable synchronous dev-mode execution.

pub fn max_pending_seconds(self, seconds: u64) -> Self

Set the maximum pending time for invocations (in seconds).

pub fn heartbeat_interval(self, seconds: u64) -> Self

Set the heartbeat interval for runners (in seconds).

pub fn argument_print_mode(self, mode: ArgumentPrintMode) -> Self

Set the argument print mode (Full, Keys, Truncated, Hidden).

pub fn hide_arguments(self) -> Self

Hide all argument values in logs and display.

pub fn truncate_arguments_length(self, length: usize) -> Self

Set the maximum length for truncated argument display.

pub fn runner_dead_after_seconds(self, seconds: u64) -> Self

Set how long (seconds) before a runner without heartbeats is considered dead.

pub fn recovery_check_interval(self, seconds: u64) -> Self

Set how often (seconds) to scan for stale invocations.

pub fn cached_status_time(self, seconds: f64) -> Self

Set the TTL for cached invocation status checks (seconds, 0 = no cache).

pub fn recover_pending_cron(self, cron: impl Into<String>) -> Self

Set the cron expression for recovering pending invocations.

pub fn recover_running_cron(self, cron: impl Into<String>) -> Self

Set the cron expression for recovering running invocations from dead runners.

pub fn trigger_task_modules(self, modules: Vec<String>) -> Self

Set module paths to scan for trigger task registration.

pub fn logging_level(self, level: impl Into<String>) -> Self

Set the logging level (trace, debug, info, warn, error).

pub fn log_format(self, format: LogFormat) -> Self

Set the log output format (Text or Json).

pub fn log_use_colors(self, use_colors: Option<bool>) -> Self

Set whether to use ANSI colors in text format (None = auto-detect TTY).

pub fn compact_log_context(self, compact: bool) -> Self

Set whether to show compact context in logs.

pub fn blocking_control(self, enabled: bool) -> Self

Set whether the orchestrator uses blocking/waiting semantics.

pub fn auto_final_invocation_purge_hours(self, hours: f64) -> Self

Set hours after which final invocations can be auto-purged (0 = disabled).

pub fn scheduler_interval(self, seconds: u64) -> Self

Set the scheduler evaluation interval in seconds.

pub fn enable_scheduler(self, enabled: bool) -> Self

Set whether the trigger scheduler is enabled.

pub fn broker(self, broker: Arc<dyn Broker>) -> Self

Use a custom broker.

pub fn orchestrator(self, orch: Arc<dyn Orchestrator>) -> Self

Use a custom orchestrator.

pub fn state_backend(self, sb: Arc<dyn StateBackend>) -> Self

Use a custom state backend.

pub fn client_data_store(self, cds: Arc<dyn ClientDataStore>) -> Self

Use a custom client data store backend.

pub fn client_data_store_config(self, config: ClientDataStoreConfig) -> Self

Configure the client data store manager.

pub fn auto_discover_tasks(self) -> Self

Auto-discover all tasks registered via #[rustvello::task] at compile time.

Uses the inventory crate to collect all [TaskEntry] instances submitted by the proc macro. This is the Rust equivalent of pynenc’s _load_plugins() via entry_points.

pub fn task_module(self, module: Box<dyn TaskModule>) -> Self

Register a TaskModule — a group of related tasks.

Equivalent to pynenc’s _register_plugin_from_entry_point().

pub fn trigger_store(self, store: Arc<dyn TriggerStore>) -> Self

Set a custom trigger store backend.

pub fn logging(self) -> LoggingBuilder

Open the logging & display sub-builder.

let app = Rustvello::builder()
    .logging()
        .level("debug")
        .compact_context(true)
        .done()
    .build().await?;

pub fn performance(self) -> PerformanceBuilder

Open the performance & scheduling sub-builder.

pub fn reliability(self) -> ReliabilityBuilder

Open the reliability & recovery sub-builder.

pub fn from_env(self) -> Self

Enable reading environment variables (RUSTVELLO__*) during build().

When called, environment variables are added to the priority chain: programmatic > env > file > defaults.

pub fn from_file(self, path: impl AsRef<Path>) -> RustvelloResult<Self>

Load task-section config from a TOML file and register the path for the cistell resolver to read [app] fields during build().

Reads [task_defaults] and [tasks.<name>] sections immediately. The [app] section is resolved later via cistell’s FileSource.

Trait Implementations

impl Debug for RustvelloBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.