Como Otimizar Requisições de API em Ruby para Melhorar a Performance

require "faraday"
require "faraday-net_http_persistent"

# Cliente com connection pooling (reutiliza conexões TCP)
module CpfHub
    class Client
    POOL_SIZE = 10

    def initialize
    @connection = Faraday.new(url: "https://api.cpfhub.io") do |conn|
    conn.headers["x-api-key"] = ENV["CPFHUB_API_KEY"]
    conn.headers["Accept-Encoding"] = "gzip"
    conn.options.timeout = 10
    conn.options.open_timeout = 5
    conn.adapter :net_http_persistent, pool_size: POOL_SIZE do |http|
    http.idle_timeout = 30
    end
    end
    end

    def consultar(cpf)
    resposta = @connection.get("/cpf/#{cpf}")
    JSON.parse(resposta.body)
    rescue Faraday::Error => e
    { "success" => false, "error" => e.message }
    end
    end
end

# Singleton para reutilizar em toda a aplicação
cliente = CpfHub::Client.new
resultado = cliente.consultar("12345678901")

require "lru_redux"

module CpfHub
    class CachedClient
    DEFAULT_TTL = 3600 # 1 hora em segundos

    def initialize(max_size: 1000, ttl: DEFAULT_TTL)
    @client = Client.new
    @cache = LruRedux::TTL::ThreadSafeCache.new(max_size, ttl)
    @hits = 0
    @misses = 0
    end

    def consultar(cpf)
    cpf_limpo = cpf.gsub(/\D/, "")

    cached = @cache[cpf_limpo]
    if cached
    @hits += 1
    return cached.merge("fonte" => "cache")
    end

    @misses += 1
    resultado = @client.consultar(cpf_limpo)

    if resultado["success"]
    @cache[cpf_limpo] = resultado
    end

    resultado.merge("fonte" => "api")
    end

    def estatisticas
    total = @hits + @misses
    taxa = total.positive? ? (@hits.to_f / total * 100).round(2) : 0

    {
    hits: @hits,
    misses: @misses,
    taxa_acerto: "#{taxa}%",
    entradas_cache: @cache.count
    }
    end

    def invalidar(cpf)
    @cache.delete(cpf.gsub(/\D/, ""))
    end

    def limpar
    @cache.clear
    end
    end
end

require "concurrent-ruby"

module CpfHub
    class ParallelClient
    def initialize(concorrencia: 5)
    @client = CachedClient.new
    @pool = Concurrent::FixedThreadPool.new(concorrencia)
    end

    def consultar_lote(cpfs)
    futures = cpfs.map do |cpf|
    Concurrent::Future.execute(executor: @pool) do
    @client.consultar(cpf)
    end
    end

    futures.map.with_index do |future, index|
    resultado = future.value(10) # Timeout de 10 segundos
    {
    cpf: cpfs[index],
    sucesso: resultado&.dig("success") || false,
    dados: resultado&.dig("data"),
    erro: future.rejected? ? future.reason.message : nil
    }
    end
    end

    def estatisticas
    @client.estatisticas
    end

    def shutdown
    @pool.shutdown
    @pool.wait_for_termination(30)
    end
    end
end

# Uso
cliente_paralelo = CpfHub::ParallelClient.new(concorrencia: 10)
cpfs = %w[12345678901 98765432100 11122233344 44455566677]
resultados = cliente_paralelo.consultar_lote(cpfs)

resultados.each do |r|
    puts "#{r[:cpf]}: #{r[:sucesso] ? r[:dados]['name'] : r[:erro]}"
end

cliente_paralelo.shutdown

module CpfHub
    class LoggingMiddleware < Faraday::Middleware
    def call(env)
    inicio = Process.clock_gettime(Process::CLOCK_MONOTONIC)

    resposta = @app.call(env)

    duracao = (
    (Process.clock_gettime(Process::CLOCK_MONOTONIC) - inicio) * 1000
    ).round(2)

    log_dados = {
    metodo: env.method.upcase,
    url: env.url.to_s.gsub(/\d{11}/, "***CPF***"),
    status: resposta.status,
    duracao_ms: duracao,
    timestamp: Time.now.iso8601
    }

    if duracao > 1000
    Rails.logger.warn("[CpfHub] Requisicao lenta: #{log_dados}")
    else
    Rails.logger.info("[CpfHub] #{log_dados}")
    end

    resposta
    end
    end
end

# Registrar o middleware no Faraday
Faraday::Middleware.register_middleware(
    cpfhub_logging: CpfHub::LoggingMiddleware
)

require "benchmark"

cpfs = gerar_lista_cpfs(100)

Benchmark.bm(25) do |x|
    x.report("Sequencial sem cache") do
    cliente_simples = CpfHub::Client.new
    cpfs.each { |cpf| cliente_simples.consultar(cpf) }
    end

    x.report("Sequencial com cache") do
    cliente_cache = CpfHub::CachedClient.new
    cpfs.each { |cpf| cliente_cache.consultar(cpf) }
    end

    x.report("Paralelo sem cache") do
    cliente_paralelo = CpfHub::ParallelClient.new(concorrencia: 10)
    cliente_paralelo.consultar_lote(cpfs)
    cliente_paralelo.shutdown
    end

    x.report("Paralelo com cache") do
    cliente_completo = CpfHub::ParallelClient.new(concorrencia: 10)
    # Segunda execução (com cache)
    cliente_completo.consultar_lote(cpfs)
    cliente_completo.shutdown
    end
end