Struct EngineBuilder 

pub struct EngineBuilder { /* private fields */ }

Builder for constructing an Engine with a fluent API.

Use Engine::builder() to create an instance. Without calling output() or shared_output(), the engine runs in benchmark mode (no output channel, no cloning overhead).

Examples

use varpulis_runtime::{Engine, Metrics};
use tokio::sync::mpsc;

// Simple construction with output channel
let (tx, _rx) = mpsc::channel(100);
let mut engine = Engine::builder()
    .output(tx)
    .build();

// Full construction with metrics, DLQ, and context name
let (tx2, _rx2) = mpsc::channel(100);
let mut engine = Engine::builder()
    .output(tx2)
    .metrics(Metrics::new())
    .context_name("worker-0")
    .dlq_path("/var/log/varpulis-dlq.jsonl")
    .build();

// Benchmark mode (no output, no cloning overhead)
let mut engine = Engine::builder().build();

Implementations

impl EngineBuilder

pub fn new() -> Self

Create a new builder with default configuration (benchmark mode, no output).

pub fn output(self, tx: Sender<Event>) -> Self

Set the output channel for emitted events (legacy owned channel).

pub fn shared_output(self, tx: Sender<SharedEvent>) -> Self

Set a zero-copy shared output channel (recommended for performance).

pub fn metrics(self, metrics: Metrics) -> Self

Enable Prometheus metrics collection.

pub fn context_name(self, name: impl Into<String>) -> Self

Set the context name for this engine instance (used in multi-context deployments).

pub fn dlq_path(self, path: impl Into<PathBuf>) -> Self

Set a custom dead-letter queue file path (default: varpulis-dlq.jsonl).

pub fn dlq_config(self, config: DlqConfig) -> Self

Set custom dead-letter queue configuration.

pub fn scalar_udf(self, udf: Arc<dyn ScalarUDF>) -> Self

Register a native scalar UDF.

pub fn aggregate_udf(self, udf: Arc<dyn AggregateUDF>) -> Self

Register a native aggregate UDF.

pub fn credentials(self, store: Arc<CredentialsStore>) -> Self

Set the connector credentials store for resolving profile: references in VPL.

pub fn build(self) -> Engine

Build the engine. Returns the configured Engine ready for load().

After building, call Engine::load() or Engine::load_with_source() to load a VPL program. Post-load configuration like Engine::enable_checkpointing() and Engine::enable_watermark_tracking() should be called after loading.

Trait Implementations

impl Debug for EngineBuilder

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

Formats the value using the given formatter.

impl Default for EngineBuilder

fn default() -> Self

Returns the “default value” for a type.