flow-guard 0.1.0

🛡️ FlowGuardNext-Generation Adaptive Concurrency Control & Backpressure for RustCriado e Desenvolvido por: Cleiton Augusto Correa BezerraO FlowGuard é uma biblioteca de próxima geração para controle de carga. Ao contrário de limitadores de taxa (rate limiters) estáticos, o FlowGuard utiliza algoritmos de controle de congestionamento (TCP Vegas) para ajustar dinamicamente os limites de carga baseando-se na latência real e na saúde do sistema.🚀 A Inovação: Por que o FlowGuard?Configurar um limite fixo (ex: "máximo 100 conexões") é uma armadilha em sistemas modernos:Limite muito alto: O sistema entra em colapso (Cascading Failure) antes de atingir o limite.Limite muito baixo: Desperdício de hardware e recusa de tráfego legítimo.O FlowGuard resolve isso com:Auto-tuning: Observa o RTT (Round Trip Time). Se a latência sobe, ele reduz a concorrência. Se o sistema está rápido, ele expande a capacidade.Resiliência Nativa: Protege bancos de dados e serviços externos de sobrecarga.Zero-Cost Abstractions: Construído com operações atômicas em Rust para performance extrema.🛠️ InstalaçãoAdicione ao seu Cargo.toml:Ini, TOML[dependencies]
# Versão Core
flow-guard = "0.1.0"

# Com suporte total a Axum 0.8 / Tower
flow-guard = { version = "0.1.0", features = ["axum", "tower"] }
💻 Exemplo de Uso (Axum 0.8)O FlowGuard é plug-and-play e utiliza o padrão moderno de middlewares do Rust.Rustuse axum::{routing::get, Router, error_handling::HandleErrorLayer};
use flow_guard::{FlowGuardLayer, VegasStrategy, FlowError};
use tower::ServiceBuilder;

#[tokio::main]
async fn main() {
// Inicializa: (Limite Inicial, Mínimo, Máximo)
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 {
                    // Retorna 503 Service Unavailable automaticamente se houver sobrecarga
                    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();
}
📊 O Algoritmo Vegas (The Math)A estratégia Vegas ajusta o limite $L$ baseado na diferença entre o RTT atual e o RTT base:$$diff = L \times \left(1 - \frac{RTT_{base}}{RTT_{actual}}\right)$$Se $diff < \alpha$: O sistema está ocioso. Aumentamos o limite para aproveitar os recursos.Se $diff > \beta$: Congestionamento detectado! Reduzimos o limite proativamente antes do crash.💼 Visão de Futuro (Versão Enterprise)O FlowGuard é um projeto Open-Core. Enquanto a versão comunitária foca em instâncias isoladas, a nossa versão Enterprise foca em:🌐 Distributed Flow Control: Controle de fluxo global sincronizado via Redis/NATS para clusters Kubernetes.📈 Observability Dashboard: Painéis em tempo real (Prometheus/Grafana) para visualizar o estrangulamento de tráfego.⚡ Dynamic Thresholds: Alteração de políticas de segurança em tempo real via Control Plane.🤝 Contato & ContribuiçõesContribuições são o coração da comunidade Rust!Autor: Cleiton Augusto Correa BezerraEmail: augusto.cleiton@gmail.comLinkedIn: cleiton-augusto-b619435b📄 LicençaEste projeto está licenciado sob a Licença MIT.