Como Usar ActiveJob para Processar Consultas de CPF em Segundo Plano no Rails

# Gemfile
gem "sidekiq", "~> 7.0"
gem "faraday", "~> 2.0"
gem "faraday-retry", "~> 2.0"

# config/application.rb
config.active_job.queue_adapter = :sidekiq

# config/sidekiq.yml
:concurrency: 10
:queues:
    - [consulta_cpf_urgente, 3]
    - [consulta_cpf_padrao, 2]
    - [consulta_cpf_lote, 1]

# app/jobs/consultar_cpf_job.rb
class ConsultarCpfJob < ApplicationJob
    queue_as :consulta_cpf_padrao

    retry_on Faraday::TimeoutError, wait: :exponentially_longer, attempts: 5
    retry_on Faraday::ConnectionFailed, wait: 30.seconds, attempts: 3
    discard_on ActiveJob::DeserializationError

    before_perform :registrar_inicio
    after_perform :registrar_conclusao

    def perform(cpf, callback_class: nil, callback_id: nil)
    cliente_api = criar_cliente_api
    resposta = cliente_api.get("/cpf/#{cpf}")

    resultado = JSON.parse(resposta.body)

    if resultado["success"]
    salvar_resultado(cpf, resultado["data"])
    executar_callback(callback_class, callback_id, resultado["data"])
    else
    registrar_falha(cpf, "CPF nao encontrado na base")
    end
    rescue Faraday::ClientError => e
    registrar_falha(cpf, "Erro na API: #{e.message}")
    raise
    end

    private

    def criar_cliente_api
    Faraday.new(url: "https://api.cpfhub.io") do |conn|
    conn.request :retry, max: 2, interval: 1, backoff_factor: 2
    conn.headers["x-api-key"] = ENV["CPFHUB_API_KEY"]
    conn.headers["Content-Type"] = "application/json"
    conn.options.timeout = 10
    conn.options.open_timeout = 5
    conn.adapter Faraday.default_adapter
    end
    end

    def salvar_resultado(cpf, dados)
    ConsultaCpf.create!(
    cpf: cpf,
    nome: dados["name"],
    genero: dados["gender"],
    data_nascimento: dados["birthDate"],
    status: "sucesso",
    consultado_em: Time.current
    )
    end

    def executar_callback(callback_class, callback_id, dados)
    return unless callback_class && callback_id

    klass = callback_class.constantize
    registro = klass.find(callback_id)
    registro.cpf_validado!(dados)
    end

    def registrar_inicio
    Rails.logger.info("[ConsultarCpfJob] Iniciando consulta")
    end

    def registrar_conclusao
    Rails.logger.info("[ConsultarCpfJob] Consulta concluida")
    end

    def registrar_falha(cpf, motivo)
    ConsultaCpf.create!(
    cpf: cpf,
    status: "falha",
    motivo_falha: motivo,
    consultado_em: Time.current
    )
    end
end

# app/controllers/api/cpf_controller.rb
module Api
    class CpfController < ApplicationController
    def consultar
    cpf = params[:cpf].gsub(/\D/, "")

    unless cpf_valido?(cpf)
    render json: { erro: "CPF invalido" }, status: :unprocessable_entity
    return
    end

    # Verificar se já existe no cache
    consulta_existente = ConsultaCpf.recente.find_by(cpf: cpf)
    if consulta_existente&.sucesso?
    render json: {
    fonte: "cache",
    dados: consulta_existente.as_json
    }
    return
    end

    # Enfileirar para processamento em background
    job = ConsultarCpfJob.perform_later(cpf)

    render json: {
    mensagem: "Consulta enfileirada com sucesso",
    job_id: job.provider_job_id,
    status: "pendente"
    }, status: :accepted
    end

    def consultar_lote
    cpfs = params[:cpfs]

    cpfs.each_with_index do |cpf, index|
    ConsultarCpfJob
    .set(queue: :consulta_cpf_lote, wait: index.seconds)
    .perform_later(cpf.gsub(/\D/, ""))
    end

    render json: {
    mensagem: "#{cpfs.size} CPFs enfileirados para processamento",
    status: "pendente"
    }, status: :accepted
    end

    private

    def cpf_valido?(cpf)
    cpf.match?(/\A\d{11}\z/) && !cpf.match?(/\A(\d)\1{10}\z/)
    end
    end
end

# db/migrate/XXXXXX_create_consultas_cpf.rb
class CreateConsultasCpf < ActiveRecord::Migration[7.1]
    def change
    create_table :consultas_cpf do |t|
    t.string :cpf, null: false, index: true
    t.string :nome
    t.string :genero
    t.date :data_nascimento
    t.string :status, null: false, default: "pendente"
    t.text :motivo_falha
    t.datetime :consultado_em

    t.timestamps
    end

    add_index :consultas_cpf, [:cpf, :created_at]
    add_index :consultas_cpf, :status
    end
end

# app/models/consulta_cpf.rb
class ConsultaCpf < ApplicationRecord
    validates :cpf, presence: true
    validates :status, inclusion: {
    in: %w[pendente sucesso falha]
    }

    scope :recente, -> { where("created_at > ?", 24.hours.ago) }
    scope :sucesso, -> { where(status: "sucesso") }
    scope :falha, -> { where(status: "falha") }

    def sucesso?
    status == "sucesso"
    end
end

# app/services/metricas_cpf_service.rb
class MetricasCpfService
    def self.resumo
    {
    total_consultas: ConsultaCpf.count,
    sucessos: ConsultaCpf.sucesso.count,
    falhas: ConsultaCpf.falha.count,
    taxa_sucesso: calcular_taxa_sucesso,
    filas: {
    urgente: Sidekiq::Queue.new("consulta_cpf_urgente").size,
    padrao: Sidekiq::Queue.new("consulta_cpf_padrao").size,
    lote: Sidekiq::Queue.new("consulta_cpf_lote").size
    },
    workers_ativos: Sidekiq::Workers.new.size
    }
    end

    def self.calcular_taxa_sucesso
    total = ConsultaCpf.count
    return 0 if total.zero?

    ((ConsultaCpf.sucesso.count.to_f / total) * 100).round(2)
    end
end