Configuration

Redlite operates with default settings that can be overridden via command-line arguments or API calls.

Server Configuration

Command Line Arguments

Argument	Short	Default	Description
--db	-d	redlite.db	Database file path
--addr	-a	127.0.0.1:6379	Listen address and port
--password		(none)	Require password for connections (like Redis requirepass)
--storage		file	Storage type: file or memory
--cache		64	SQLite page cache size in MB (larger = faster reads)
--max-memory		0	Maximum memory size in bytes (0 = unlimited). Evicts keys based on policy
--max-disk		0	Maximum disk size in bytes (0 = unlimited). Evicts oldest keys when exceeded
--eviction-policy		noeviction	Memory eviction policy: noeviction, allkeys-lru, allkeys-lfu, allkeys-random, volatile-lru, volatile-lfu, volatile-ttl, volatile-random

Database Path

# Persistent file
./redlite --db /var/lib/redlite/data.db

# In-memory (no persistence)
./redlite --storage memory

Network Binding

# Localhost only (default)
./redlite --addr 127.0.0.1:6379

# All interfaces
./redlite --addr 0.0.0.0:6379

# Custom port
./redlite --addr 127.0.0.1:6380

Authentication

# Require password for all connections
./redlite --db mydata.db --password secret

Performance Tuning

# Use 1GB cache for high-performance reads
./redlite --db mydata.db --cache 1024

# Default: 64MB cache
./redlite --db mydata.db

The --cache flag sets SQLite’s page cache size. Larger values keep more data in RAM for faster reads while maintaining full durability.

Memory Eviction

# Limit to 100MB with LRU eviction
./redlite --db mydata.db --max-memory 104857600 --eviction-policy allkeys-lru

# LFU policy for frequency-based eviction
./redlite --db mydata.db --max-memory 104857600 --eviction-policy allkeys-lfu

When --max-memory is set, redlite tracks access patterns and evicts keys based on the configured policy. The eviction process uses a vacuum-first strategy: expired keys are removed before evicting valid keys.

Available policies:

• noeviction - Return errors when memory limit is reached (default)
• allkeys-lru - Evict least recently used keys
• allkeys-lfu - Evict least frequently used keys
• allkeys-random - Evict random keys
• volatile-lru - Evict least recently used keys with TTL
• volatile-lfu - Evict least frequently used keys with TTL
• volatile-ttl - Evict keys closest to expiration
• volatile-random - Evict random keys with TTL

Runtime adjustment:

# Via redis-cli or any Redis client
CONFIG SET maxmemory 52428800           # Change to 50MB
CONFIG SET maxmemory-policy allkeys-lfu # Switch to LFU
CONFIG GET maxmemory                    # Check current limit

See Eviction for detailed documentation.

Disk Eviction

# Limit database to 100MB on disk
./redlite --db mydata.db --max-disk 104857600

When --max-disk is set, redlite automatically evicts the oldest keys (by creation time) when disk usage exceeds the limit. Eviction checks run every second during write operations.

Runtime adjustment:

# Via redis-cli or any Redis client
CONFIG SET maxdisk 52428800  # Change to 50MB
CONFIG GET maxdisk            # Check current limit

Library Configuration

When using Redlite as an embedded library, configuration is done through code:

use redlite::Db;

// Persistent database
let db = Db::open("/path/to/data.db")?;

// In-memory database
let db = Db::open_memory()?;

// With custom cache size (1GB)
let db = Db::open_with_cache("/path/to/data.db", 1024)?;

// Or set cache at runtime
let db = Db::open("/path/to/data.db")?;
db.set_cache_mb(1024)?;

// Select database (0-15)
let mut db = Db::open("/path/to/data.db")?;
db.select(1)?;

// Configure memory eviction
use redlite::EvictionPolicy;
db.set_max_memory(100 * 1024 * 1024)?;  // 100MB limit
db.set_eviction_policy(EvictionPolicy::AllKeysLru);

// Configure access tracking persistence
db.set_persist_access_tracking(true);   // Persist LRU/LFU data to SQLite
db.set_access_flush_interval(5000);     // Flush every 5 seconds

SQLite Settings

Redlite configures SQLite with these defaults:

Setting	Value	Purpose
journal_mode	WAL	Write-ahead logging for concurrent readers
synchronous	NORMAL	Fsync at checkpoints, not every commit
foreign_keys	ON	Enforce foreign key constraints
busy_timeout	5000ms	Wait duration for locked database

These settings are applied automatically when opening a database and cannot currently be changed.

Environment Variables

Currently, Redlite does not use environment variables. All configuration is done via command line arguments or programmatically.

Logging

Redlite uses the tracing crate for logging. Configure with standard Rust logging environment variables:

# Enable info logging
RUST_LOG=info ./redlite --db mydata.db

# Debug logging
RUST_LOG=debug ./redlite --db mydata.db

# Trace logging (very verbose)
RUST_LOG=trace ./redlite --db mydata.db

Database Limits

Limit	Value
Max databases	16 (0-15)
Max key size	~1GB (SQLite blob limit)
Max value size	~1GB (SQLite blob limit)
Max database size	~281TB (SQLite limit)

In practice, you’ll hit disk space limits long before SQLite limits.