Quem me acompanha por aqui sabe o quanto eu defendo a criação de APIs web modernas, escaláveis e robustas utilizando o Delphi. O ecossistema evoluiu drasticamente nos últimos anos com o amadurecimento de soluções como o micro-framework Horse e a chegada do inovador Dext Framework (um framework full-stack completo que traz padrões modernos semelhantes ao .NET Core para o Object Pascal). Juntos, eles provam que é possível desenvolver soluções de altíssima performance para a web com a mesma maturidade, recursos e segurança que costumamos ver em plataformas como Node.js, .NET ou Go.

No entanto, manter um core enxuto significa que a evolução de recursos adicionais deve acontecer através de um ecossistema de middlewares. Nos últimos dias, estive trabalhando ativamente no desenvolvimento e refinamento de cinco novos middlewares de alta performance e padrão enterprise para suprir necessidades cruciais de segurança, otimização e observabilidade em aplicações Delphi e Lazarus no Horse.

Neste artigo, vou detalhar o que cada um deles faz, por que você deve utilizá-los em seus projetos e como começar de forma simples e rápida.

Horse Rate Limit: Proteção e Controle de Tráfego

Expor sua API na internet sem um controle de tráfego é um convite para lentidões e indisponibilidade. Seja por ataques de força bruta, tentativas de negação de serviço (DoS) ou robôs de scraping fazendo requisições em velocidade sobre-humana, sua API precisa de proteção.

O Horse Rate Limit é um middleware thread-safe e de alta performance que gerencia o limite de requisições que um cliente pode fazer em um determinado intervalo de tempo.

Principais diferenciais:

• Janela Fixa e Deslizante: Suporta o algoritmo clássico de janela fixa e o moderno Sliding Window Counter (janela deslizante) para evitar picos de tráfego nas viradas de minuto.
• Armazenamento Distribuído com Redis: Pronto para rodar em clusters de APIs balanceados, centralizando a contagem de acessos no Redis através de scripts Lua atômicos.
• Prevenção de IP Spoofing (Trust Proxy): Lê e valida cabeçalhos de proxy de forma segura (como CF-Connecting-IP do Cloudflare ou X-Forwarded-For).
• Bypass Dinâmico e CIDR: Permite definir Whitelists/Blacklists com suporte a faixas de IP por notação CIDR (ex: 10.0.0.0/8) e funções de escape customizadas (Skip).

Exemplo prático de uso:

uses
  Horse,
  Horse.RateLimit;

begin
  // Limite de 100 requisições por minuto por IP do cliente
  THorse.Use(THorseRateLimit.New(
    THorseRateLimitConfig.Default
      .Limit(100)
      .WindowSeconds(60)
      .Algorithm(rlaSlidingWindow)
  ));

  THorse.Get('/ping',
    procedure(Req: THorseRequest; Res: THorseResponse)
    begin
      Res.Send('pong');
    end
  );

  THorse.Listen(9000);
end.

👉 Repositório no GitHub: regyssilveira/horse-rate-limit

Horse Static: Servidor de Arquivos Estáticos Enterprise

Servir arquivos locais (como imagens, PDFs, vídeos ou builds de aplicações front-end) diretamente de sua API pode se tornar um gargalo de desempenho se a leitura física de disco ocorrer a cada requisição ou se não houver suporte a streaming parcial.

O Horse Static é um middleware de serviço de arquivos de alta performance e 100% provider-agnostic, projetado para otimizar a entrega de recursos do lado do cliente.

Principais diferenciais:

• Suporte a HTTP 206 (Ranges): Permite reprodução parcial de mídias (streaming de áudio/vídeo) onde o navegador solicita blocos específicos de bytes, possibilitando avançar e retroceder a timeline sem baixar o arquivo inteiro.
• Cache Inteligente (ETags e Last-Modified): Gera hashes de verificação com base nos metadados do arquivo. Se o arquivo não mudou, responde com 304 Not Modified instantaneamente, economizando disco e banda de rede.
• Modo SPA Fallback: Redireciona de forma transparente rotas virtuais inexistentes no disco para um arquivo raiz (como index.html), essencial para hospedar apps React, Vue ou Angular roteados no client-side.
• Storage Desacoplado: A arquitetura baseada em interfaces permite ler arquivos do disco local ou estender o provedor para ler diretamente de nuvens (AWS S3, Azure Blob) ou memória RAM.

Exemplo prático de uso:

uses
  Horse,
  Horse.Static;

begin
  // Hospeda uma aplicação SPA com cache e suporte a ranges
  THorse.Use(THorseStatic.Middleware(
    THorseStatic.New('./dist')
      .SpaFallback('index.html')
      .CacheControl('public, max-age=31536000')
    )
  );

  THorse.Listen(9000);
end.

👉 Repositório no GitHub: regyssilveira/horse-static

Horse Compression v2: Compressão de Alta Performance

A velocidade de uma API está intimamente ligada ao tamanho do payload trafegado. Compactar respostas textuais (JSON, XML, HTML) reduz consideravelmente o tempo de latência de tráfego na rede, principalmente em conexões móveis.

O Horse Compression v2 é uma reescrita focada em baixíssima alocação de memória (zero-allocation) e suporte a múltiplos algoritmos modernos de compressão.

Principais diferenciais:

• Suporte a Gzip, Deflate e Brotli: Negociação automática dos algoritmos com base no suporte do navegador (cabeçalho Accept-Encoding).
• Compressão Opcional Brotli (br): Algoritmo de compressão do Google que oferece taxas até 30% superiores ao Gzip tradicional. Ele é compilado opcionalmente via diretivas de compilação para manter a portabilidade padrão leve.
• Zero-Allocation e Fail-safe: Otimizado para não gerar sobrecarga no Heap Memory, sendo compatível com Providers assíncronos de alta concorrência como IOCP e epoll.

Exemplo prático de uso:

uses
  Horse,
  Horse.Compression;

begin
  // Compactação inteligente ativada globalmente no pipeline
  THorse.Use(HorseCompression);

  THorse.Get('/dados',
    procedure(Req: THorseRequest; Res: THorseResponse)
    begin
      Res.Send(CarregarGrandeMassaDeDadosJSON);
    end
  );

  THorse.Listen(9000);
end.

👉 Repositório no GitHub: regyssilveira/horse-compression-v2

Horse Prometheus: Observabilidade e Coleta de Métricas

Não há como otimizar ou corrigir o que não conseguimos medir. Em ambientes modernos, o monitoramento preventivo de latência e consumo de recursos é o pilar que diferencia sistemas amadores de sistemas estáveis de produção.

O Horse Prometheus expõe métricas em tempo real no padrão aberto esperado pelo coletor do Prometheus, que posteriormente podem ser consumidas para alimentar belíssimos e dinâmicos painéis de monitoramento do Grafana.

Principais diferenciais:

• Métricas Padronizadas (RED Method): Expõe o número total de requisições (http_requests_total), tempo médio de duração das rotas (http_request_duration_seconds) e quantidade de execuções simultâneas em andamento (http_active_requests).
• Thread-Safe e Concorrente: Mapeamentos de chaves de métricas protegidos por seções críticas de alta velocidade, suportando milhares de concorrências de escrita sem gargalos.
• Fácil Configuração Docker: O projeto já traz arquivos de configuração do Docker Compose prontos contendo Prometheus e Grafana pré-configurados para iniciar o monitoramento local em segundos.

Exemplo prático de uso:

uses
  Horse,
  Horse.Prometheus;

begin
  // Expõe automaticamente o endpoint '/metrics' com dados de observabilidade
  THorse.Use(THorsePrometheus.Middleware);
  THorse.Get('/users', ...);
  THorse.Listen(9000);
end.

👉 Repositório no GitHub: regyssilveira/horse-prometheus

Horse OpenTelemetry: Rastreamento Distribuído W3C

Quando nossa aplicação migra para uma arquitetura orientada a serviços ou microsserviços, debugar uma falha vira um pesadelo: a requisição passa pelo Gateway, bate em dois serviços diferentes, consulta um banco de dados e estoura um erro. Qual serviço falhou e qual foi a causa?

O Horse OpenTelemetry implementa a especificação oficial W3C Trace Context para prover propagação de contexto distribuído de forma transparente nas suas APIs Delphi e Lazarus.

Principais diferenciais:

• Propagação de Contexto Distribuído: Lê e injeta cabeçalhos padrão traceparent (formato: 00-{traceid}-{spanid}-{traceflags}). Se a chamada externa iniciou em outro microsserviço (mesmo que escrito em C#, Java ou Node.js), sua API Delphi continuará a cadeia usando o mesmo ID exclusivo de rastreamento.
• Integração com APMs (Jaeger, Zipkin): Permite o mapeamento visual do tempo gasto em cada serviço da rede e a identificação rápida do serviço gargalo do ecossistema.
• Sem Vazamento de Memória (Memory Leak Free): Gerenciamento inteligente e automatizado do ciclo de vida dos objetos de contexto gravados no State do request do Horse.

Exemplo prático de uso:

uses
  Horse,
  Horse.OpenTelemetry;

begin
  // Registra o middleware de OpenTelemetry para capturar o ciclo completo do request
  THorse.Use(THorseOpenTelemetry.Middleware);
  THorse.Get('/orders',
    procedure(Req: THorseRequest; Res: THorseResponse)
    var
      LOtelCtx: THorseOpenTelemetryContext;
    begin
      LOtelCtx := THorseOpenTelemetryContext(Req.State.Items['otel.context']);

      // Utilize o TraceID e SpanID para correlação de logs de banco de dados ou chamadas externas
      LogarComTraceId(LOtelCtx.TraceId, 'Iniciando processamento da ordem...');

      Res.Send('{"status": "processed"}');
    end
  );  

  THorse.Listen(9000);
end.

👉 Repositório no GitHub: regyssilveira/horse-opentelemetry

Conclusão

Com a introdução desses novos middlewares, o desenvolvimento de APIs web robustas em Delphi e Lazarus ganha uma fundação sólida de nível enterprise. É possível focar 100% nas regras de negócio da sua empresa sabendo que segurança (Rate Limiting), infraestrutura (Static Serving), otimização (Compression) e monitoramento moderno (Prometheus / OpenTelemetry) já estão resolvidos com maestria.

Todos estes middlewares são 100% de código aberto (Open Source) e compatíveis com compiladores Delphi XE7+ e Lazarus/FPC. Baixe-os através do gerenciador de dependências Boss, teste em seus projetos e compartilhe os resultados!

Ficou com alguma dúvida ou tem sugestões de melhorias? Deixe seu comentário abaixo!