🐰 BugBunny

gem 'bug_bunny', '~> 4.0'

# config/initializers/bug_bunny.rb

BugBunny.configure do |config|
  # 1. Credenciales
  config.host     = ENV.fetch('RABBITMQ_HOST', 'localhost')
  config.username = ENV.fetch('RABBITMQ_USER', 'guest')
  config.password = ENV.fetch('RABBITMQ_PASS', 'guest')
  config.vhost    = ENV.fetch('RABBITMQ_VHOST', '/')

  # 2. Timeouts y Recuperación
  config.rpc_timeout = 10               # Segundos máx para esperar respuesta (Síncrono)
  config.network_recovery_interval = 5  # Base del backoff de reconexión (segundos)
  config.max_reconnect_interval    = 60 # Techo del backoff exponencial (segundos)
  config.max_reconnect_attempts    = nil # nil = reintenta infinitamente; Integer = falla hard

  # 3. Health Checks (Opcional, para Docker Swarm / K8s)
  config.health_check_file = '/tmp/bug_bunny_health'

  # 4. Logging
  config.logger = Rails.logger
end

# 5. Connection Pool (CRÍTICO para concurrencia)
# Define un pool global para compartir conexiones entre hilos
BUG_BUNNY_POOL = ConnectionPool.new(size: ENV.fetch('RAILS_MAX_THREADS', 5).to_i, timeout: 5) do
  BugBunny.create_connection
end

# Inyecta el pool en los recursos
BugBunny::Resource.connection_pool = BUG_BUNNY_POOL

# config/initializers/bug_bunny.rb
BugBunny.configure do |config|
  if Rails.env.test?
    config.exchange_options = { auto_delete: true }
    config.queue_options    = { auto_delete: true }
  end
end

# app/models/manager/service.rb
class Manager::Service < BugBunny::Resource
  # Configuración de Transporte
  self.exchange = 'cluster_events'
  self.exchange_type = 'topic'

  # Configuración de Infraestructura Específica (Nivel 3)
  # Este recurso crítico sobrevivirá a reinicios del servidor RabbitMQ
  self.exchange_options = { durable: true, auto_delete: false }

  # Configuración de Ruteo (La "URL" base)
  self.resource_name = 'services'

  # A. Atributos Tipados (Opcional, para casting)
  attribute :created_at, :datetime
  attribute :replicas, :integer, default: 1

  # B. Validaciones (Funcionan en ambos tipos)
  validates :name, presence: true
end

# --- LEER (GET) ---
# RPC: Espera respuesta del worker.
# Envia: GET services/123
service = Manager::Service.find('123')

# --- BÚSQUEDAS AVANZADAS ---
# Soporta Hashes anidados para filtros complejos.
# Envia: GET services?q[status]=active&q[tags][]=web
Manager::Service.where(q: { status: 'active', tags: ['web'] })

# --- CREAR (POST) ---
# RPC: Envía payload y espera el objeto persistido.
# Payload: { "service": { "name": "nginx", "replicas": 3 } }
svc = Manager::Service.create(name: 'nginx', replicas: 3)

# --- ACTUALIZAR (PUT) ---
# Dirty Tracking: Solo envía los campos que cambiaron.
svc.name = 'nginx-pro'
svc.save

# --- ELIMINAR (DELETE) ---
svc.destroy

# Nivel 4: Configuración al vuelo. Inyectamos opciones solo para esta llamada.
Manager::Service.with(
  routing_key: 'high_priority',
  exchange_options: { durable: false } # Ignora el durable: true de la clase
).create(name: 'redis_temp')

# Uso con el cliente manual
client = BugBunny::Client.new(pool: BUG_BUNNY_POOL) do |stack|
  stack.use BugBunny::Middleware::RaiseError
  stack.use BugBunny::Middleware::JsonResponse
end

# 1. Método genérico 'send' (Estilo Faraday)
# El comportamiento (RPC o Fire-and-forget) depende de 'delivery_mode'
client.delivery_mode = :rpc # Default
client.send('users/1', method: :get)

# 2. Configuración flexible del modo de entrega
# Por cada petición
client.send('logs', method: :post, body: { msg: 'system_up' }, delivery_mode: :publish)

# O mediante un bloque para configuración avanzada
client.send('users/1') do |req|
  req.method = :get
  req.delivery_mode = :rpc
  req.timeout = 5
end

# 3. Métodos de conveniencia (Atajos)
client.request('users/1') # Siempre :rpc
client.publish('events', body: { type: 'click' }) # Siempre :publish

# Ahora el cliente devolverá Hashes y lanzará errores si el worker falla
response = client.request('users/1', method: :get)

class Manager::Service < BugBunny::Resource
  client_middleware do |stack|
    stack.use(Class.new(BugBunny::Middleware::Base) do
      def on_request(env)
        env.headers['Authorization'] = "Bearer #{ENV['API_TOKEN']}"
        env.headers['X-App-Version'] = '1.0.0'
      end
    end)
  end
end

# config/initializers/bug_bunny_custom_errors.rb
module CustomBugBunnyErrors
  def on_complete(response)
    status = response['status'].to_i

    # 1. Reglas específicas de tu negocio
    if status == 402
      raise MyApp::PaymentRequiredError, response['body']['message']
    elsif status == 403 && response['body']['reason'] == 'ip_blocked'
      raise MyApp::IpBlockedError, response['body']['detail']
    end

    # 2. Delegar el resto de los errores (404, 422, 500) al middleware original
    super(response)
  end
end

BugBunny::Middleware::RaiseError.prepend(CustomBugBunnyErrors)

# config/initializers/bug_bunny_routes.rb

BugBunny.routes.draw do
  # 1. Colecciones Básicas y Filtrado
  # Genera rutas para index, show y update únicamente
  resources :services, only: [:index, :show, :update]

  # 2. Rutas Anidadas (Member y Collection)
  resources :nodes, except: [:create, :destroy] do
    # Member inyecta el parámetro :id (ej. PUT nodes/:id/drain)
    member do
      put :drain
      post :restart
    end

    # Collection opera sobre el conjunto (ej. GET nodes/stats)
    collection do
      get :stats
    end
  end

  # 3. Rutas estáticas (Colecciones o Acciones Custom)
  get 'health_checks/up', to: 'health_checks#up'

  # 4. Extracción automática de variables dinámicas profundas
  get 'api/v1/clusters/:cluster_id/nodes/:node_id/metrics', to: 'api/v1/metrics#show'
end

class ServicesController < BugBunny::Controller
  # Callbacks estándar
  before_action :set_service, only: [:show, :update]

  def show
    # Renderiza JSON que viajará de vuelta por la cola reply-to
    render status: 200, json: { id: @service.id, state: 'running' }
  end

  def create
    # BugBunny envuelve los params automáticamente basándose en el resource_name
    # params[:service] => { name: '...', replicas: ... }
    if Service.create(params[:service])
      render status: 201, json: { status: 'created' }
    else
      render status: 422, json: { errors: 'Invalid' }
    end
  end

  private

  def set_service
    # params[:id] es extraído e inyectado por el BugBunny.routes
    @service = Service.find(params[:id])
  end
end

class ApplicationController < BugBunny::Controller
  rescue_from ActiveRecord::RecordNotFound do |e|
    render status: :not_found, json: { error: "Resource missing" }
  end

  rescue_from StandardError do |e|
    BugBunny.configuration.logger.error(e)
    render status: :internal_server_error, json: { error: "Crash" }
  end
end

# app/rabbit/controllers/application_controller.rb
class ApplicationController < BugBunny::Controller
  self.log_tags = [
    ->(c) { c.params[:tenant_id] }, # Agrega [Tenant-55]
    ->(c) { c.headers['X-Source'] } # Agrega [Console]
  ]
end

# config/initializers/bug_bunny.rb
# Middleware para inyectar Current.request_id de Rails al mensaje Rabbit
class CorrelationInjector < BugBunny::Middleware::Base
  def on_request(env)
    env.correlation_id = Current.request_id if defined?(Current)
  end
end

BugBunny::Client.prepend(Module.new {
  def initialize(pool:)
    super
    @stack.use CorrelationInjector
  end
})

BugBunny.configure do |config|
  config.network_recovery_interval = 5   # Base del backoff
  config.max_reconnect_interval    = 60  # Techo máximo de espera
  config.max_reconnect_attempts    = 10  # Falla hard después de 10 intentos
end

# config/initializers/bug_bunny.rb
BugBunny.configure do |config|
  # Actualizará la fecha de este archivo si la conexión a la cola está sana
  config.health_check_file = '/tmp/bug_bunny_health'
end