flow-guard 0.1.2

🛡️ FlowGuard: Next-Generation Adaptive Concurrency Control & Backpressure for Rust
Crates.io | License: MIT | Rust

🎯 About the Project
Created and developed by: Cleiton Augusto Correa Bezerra

FlowGuard is a next-generation load control library. Unlike static rate limiters, FlowGuard uses congestion control algorithms (TCP Vegas) to dynamically adjust load limits based on real latency and system health.

🚀 The Innovation: Why FlowGuard?
Setting a fixed limit (e.g., "maximum 100 connections") is a trap in modern systems:

Limit too high: System crashes (Cascading Failure) before reaching the limit

Limit too low: Wasted hardware and refusal of legitimate traffic

FlowGuard solves this with:

✅ Auto-tuning:
Observes RTT (Round Trip Time). If latency rises, it reduces concurrency. If the system is fast, it expands capacity.

✅ Native Resilience:
Protects databases and external services from overload.

✅ Zero-Cost Abstractions:
Built with atomic operations in Rust for extreme performance.

📦 Installation
Add this to your Cargo.toml:

toml
[dependencies]
# Core Version
flow-guard = "0.1.0"

# With full Axum 0.8 / Tower support
flow-guard = { version = "0.1.0", features = ["axum", "tower"] }
🚀 Quick Start (Axum 0.8)
FlowGuard is plug-and-play and uses the modern Rust middleware pattern.

rust
use axum::{routing::get, Router, error_handling::HandleErrorLayer};
use flow_guard::{FlowGuardLayer, VegasStrategy, FlowError};
use tower::ServiceBuilder;

#[tokio::main]
async fn main() {
// Initialize: (Initial Limit, Minimum, Maximum)
let strategy = VegasStrategy::new(10, 2, 100);
let flow_layer = FlowGuardLayer::new(strategy);

    let app = Router::new()
        .route("/api/data", get(|| async { "Hello from Protected API!" }))
        .layer(
            ServiceBuilder::new()
                .layer(HandleErrorLayer::new(|err: FlowError<std::convert::Infallible>| async move {
                    // Automatically returns 503 Service Unavailable if overloaded
                    axum::response::IntoResponse::into_response(err)
                }))
                .layer(flow_layer)
        );

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}
📊 The Vegas Algorithm (The Math)
The Vegas strategy adjusts the limit $L$ based on the difference between current RTT and base RTT:

d
i
f
f
=
L
×
(
1
−
R
T
T
b
a
s
e
R
T
T
a
c
t
u
a
l
)
diff=L×(1−
RTT
actual
​

RTT
base
​

​
)
If $diff < \alpha$: System is idle. We increase the limit to utilize resources.

If $diff > \beta$: Congestion detected! We proactively reduce the limit before crash.

🔧 Features
✅ Dynamic Adaptation
Real-time concurrency adjustment based on system health

Proactive congestion prevention

No manual tuning required

✅ Resilience Patterns
Protects against cascading failures

Preserves system stability under load

Graceful degradation

✅ Production Ready
Built with atomic operations for maximum performance

Zero-cost abstractions

Seamless integration with Axum/Tower ecosystem

✅ Observability
Built-in metrics collection

Easy integration with Prometheus

Real-time monitoring capabilities

💼 Future Vision (Enterprise Edition)
FlowGuard is an Open-Core project. While the community version focuses on isolated instances, our Enterprise Edition focuses on:

🌐 Distributed Flow Control
Global flow control synchronized via Redis/NATS for Kubernetes clusters

📈 Observability Dashboard
Real-time panels (Prometheus/Grafana) to visualize traffic throttling

⚡ Dynamic Thresholds
Real-time security policy changes via Control Plane

📚 Documentation
Full API documentation is available on docs.rs

🤝 Contributing
Contributions are the heart of the Rust community! Feel free to submit pull requests or open issues.

Author: Cleiton Augusto Correa Bezerra
Email: augusto.cleiton@gmail.com
LinkedIn: cleiton-augusto-b619435b

📄 License
This project is licensed under the MIT License - see the LICENSE file for details.

Made with ❤️ and Rust