bug_bunny 3.0.0 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e154bfecb70c1fc85408e87876976dfc8c64c01c2816c4f811a05e39e8432f9
-  data.tar.gz: 3b4e1508cd1a7f019fb638831c58117d00c46729b4f6bad4f8ecaf1b75914b47
+  metadata.gz: 42bf10dd1d3e749561b43b298e6dda00f9b6a76a40dce49103d1d094faa39948
+  data.tar.gz: 3088ecec60567a95972ed7abc7dff8f6dd9f5019ad6e0a19bb15dcae61e68bb3
 SHA512:
-  metadata.gz: b43ec72552e6d17601665f7640aedd1e9c390463f6df5ca950b082e17316e387d0a10fa9e5ddfd3611d3f928a5d7d2af71367fa6c5409ba1f242402bd46843a1
-  data.tar.gz: cdd64f5401a653a0fe839ea2a3cf926e1af7de6e8498892bbd20876ea2ed808f97d4db1daa1a31f70c54533a00f73e834a547943d34f8a95543b1befeb5a9591
+  metadata.gz: ccf976738d355512f3effec2d84a94087c62b41b329516df4cb15ca99034385da216592a7b52acec6aa224708b7c5c272f17dde349a8d5fe88f3903e33ff1122
+  data.tar.gz: 60252a5667d1178b4ac9de5118dd21cfd5538c12c9f69360988f493ffea50c81e4efec2cc08f50570fc9e76c9a57d9bb08c1ef6d75aef4a6b25f995fc765b512

data/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [3.0.2] - 2026-02-12
+
+### 🚀 Features
+* **Automatic Parameter Wrapping:** `BugBunny::Resource` now automatically wraps the payload inside a root key derived from the model name (e.g., `Manager::Service` -> `{ service: { ... } }`). This mimics Rails form behavior and enables the use of `params.require(:service)` in controllers.
+    * Added `self.param_key = '...'` to `BugBunny::Resource` to allow custom root keys.
+* **Declarative Error Handling:** Added Rails-like `rescue_from` DSL to `BugBunny::Controller`. You can now register exception handlers at the class level without overriding methods manually.
+    ```ruby
+    rescue_from ActiveRecord::RecordNotFound do |e|
+      render status: :not_found, json: { error: e.message }
+    end
+    ```
+
+### 🐛 Bug Fixes
+* **RPC Timeouts on Crash:** Fixed a critical issue where the Client would hang until timeout (`BugBunny::RequestTimeout`) if the Consumer crashed or the route was not found.
+    * The Consumer now catches `NameError` (Route not found) and returns a **501 Not Implemented**.
+    * The Consumer catches unhandled `StandardError` (App crash) and returns a **500 Internal Server Error**.
+    * Ensures a reply is ALWAYS sent to the caller, preventing blocking processes.
+
+### 🛠 Improvements
+* **Controller:** Refactored `BugBunny::Controller` to include a default safety net that catches unhandled errors and logs them properly before returning a 500 status.
+
+## [3.0.1] - 2026-02-10
+
+### 🚀 Features: RESTful Architecture
+* **HTTP Verbs over AMQP:** Implemented support for semantic HTTP verbs (`GET`, `POST`, `PUT`, `DELETE`) within AMQP headers (`x-http-method`). This enables a true RESTful design over RabbitMQ.
+* **Smart Router:** The `BugBunny::Consumer` now behaves like a Rails Router. It automatically infers the controller action based on the combination of the **Verb** and the **URL Path** (e.g., `GET users/1` dispatches to `show`, `POST users` to `create`).
+* **Resource CRUD Mapping:** `BugBunny::Resource` now maps Ruby operations to their specific REST verbs:
+    * `create` -> `POST`
+    * `update` -> `PUT`
+    * `destroy` -> `DELETE`
+    * `find/where` -> `GET`.
+
+### 🛠 Improvements
+* **Client API:** Updated `BugBunny::Client#request` and `#publish` to accept a `method:` argument (e.g., `client.request('users', method: :post)`), giving developers full control over the request semantics without changing the method signature.
+* **Request Metadata:** `BugBunny::Request` now handles the `method` attribute and ensures it is properly injected into the AMQP headers for the consumer to read.
+
 ## [3.0.0] - 2026-02-05
 
 ### ⚠ Breaking Changes

data/README.md

@@ -2,7 +2,7 @@
 
 **BugBunny** es un framework RPC para Ruby on Rails sobre **RabbitMQ**.
 
-Su filosofía es **"Active Record over AMQP"**. Abstrae la complejidad de colas y exchanges transformando patrones de mensajería en una arquitectura **RESTful simulada**, donde los mensajes contienen "URLs" y "Query Params" que son enrutados automáticamente a controladores.
+Su filosofía es **"Active Record over AMQP"**. Transforma la complejidad de la mensajería asíncrona en una arquitectura **RESTful simulada**. Los mensajes viajan con Verbos HTTP (`GET`, `POST`, `PUT`, `DELETE`) inyectados en los headers AMQP, permitiendo que un **Router Inteligente** despache las peticiones a controladores Rails estándar.
 
 ---
 
@@ -20,251 +20,262 @@ Ejecuta el bundle:
 bundle install
 ```
 
-Corre el instalador para generar la configuración:
+Genera los archivos de configuración iniciales:
 
 ```bash
 rails g bug_bunny:install
 ```
 
+Esto creará:
+1.  `config/initializers/bug_bunny.rb`
+2.  `app/rabbit/controllers/`
+
 ---
 
 ## ⚙️ Configuración
 
-Configura tus credenciales y el Pool de conexiones en el inicializador.
+### 1. Inicializador y Logging
+
+BugBunny separa los logs de la aplicación (Requests) de los logs del driver (Heartbeats/Frames) para mantener la consola limpia.
 
 ```ruby
 # config/initializers/bug_bunny.rb
 
 BugBunny.configure do |config|
+  # --- 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', '/')
 
-  # Timeouts y Recuperación
-  config.rpc_timeout = 10       # Segundos a esperar respuesta síncrona
-  config.network_recovery_interval = 5
+  # --- Timeouts ---
+  config.rpc_timeout = 10               # Timeout para esperar respuesta (Síncrono)
+  config.network_recovery_interval = 5  # Segundos para reintentar conexión
+
+  # --- Logging (Niveles recomendados) ---
+  # Logger de BugBunny: Muestra tus requests (INFO)
+  config.logger = Logger.new(STDOUT)
+  config.logger.level = Logger::INFO
+
+  # Logger de Bunny (Driver): Silencia el ruido de bajo nivel (WARN)
+  config.bunny_logger = Logger.new(STDOUT)
+  config.bunny_logger.level = Logger::WARN
 end
+```
+
+### 2. Connection Pool (Crítico) 🧵
 
-# Definimos el Pool Global (Vital para Puma/Sidekiq)
+Para entornos concurrentes como **Puma** o **Sidekiq**, es **obligatorio** definir un Pool de conexiones global. BugBunny no gestiona hilos automáticamente sin esta configuración.
+
+```ruby
+# config/initializers/bug_bunny.rb
+
+# Define el pool global (ajusta el tamaño según tus hilos de Puma/Sidekiq)
 BUG_BUNNY_POOL = ConnectionPool.new(size: ENV.fetch('RAILS_MAX_THREADS', 5).to_i, timeout: 5) do
   BugBunny.create_connection
 end
 
-# Inyectamos el pool por defecto a los recursos
+# Inyecta el pool a los recursos para que lo usen automáticamente
 BugBunny::Resource.connection_pool = BUG_BUNNY_POOL
 ```
 
 ---
 
-## 🚀 Modo Resource (ORM / Active Record)
+## 🚀 Modo Resource (ORM / Cliente)
 
-Define modelos que actúan como proxis de recursos remotos. BugBunny separa la **Lógica de Transporte** (RabbitMQ) de la **Lógica de Aplicación** (Controladores).
+Define modelos que actúan como proxies de recursos remotos. BugBunny se encarga de serializar, "wrappear" parámetros y enviar el verbo correcto.
 
-### Escenario A: Routing Dinámico (Topic / Estándar)
-Ideal cuando quieres enrutar por acción. La Routing Key se genera automáticamente usando `resource_name.action`.
+### Definición del Modelo
 
 ```ruby
-class RemoteUser < BugBunny::Resource
-  # --- Configuración ---
-  self.exchange = 'app.topic'
-  self.exchange_type = 'topic'
-  
-  # Define el nombre lógico del recurso.
-  # 1. Routing Key: 'users.create', 'users.show.12'
-  # 2. Header Type: 'users/create', 'users/show/12'
-  self.resource_name = 'users'
-
-  # No necesitas definir atributos, BugBunny soporta atributos dinámicos (Schema-less)
-end
-```
+# app/models/manager/service.rb
+class Manager::Service < BugBunny::Resource
+  # 1. Configuración de Transporte
+  self.exchange = 'box_cluster_manager'
+  self.exchange_type = 'direct'
 
-### Escenario B: Routing Estático (Direct / Cola Dedicada)
-Ideal cuando quieres enviar todo a una cola específica (ej: un Manager), independientemente de la acción.
+  # 2. Configuración Lógica (Routing)
+  # Define la URL base y la routing key por defecto.
+  self.resource_name = 'services'
 
-```ruby
-class BoxManager < BugBunny::Resource
-  # --- Configuración ---
-  self.exchange = 'warehouse.direct'
-  self.exchange_type = 'direct'
-  
-  # FORZAMOS LA ROUTING KEY.
-  # Todo viaja con esta key, sin importar la acción.
-  self.routing_key = 'manager_queue'
-
-  # Define el nombre lógico para el Controlador.
-  # Header Type: 'box_manager/create', 'box_manager/show/12'
-  self.resource_name = 'box_manager'
+  # 3. Wrapping de Parámetros (Opcional)
+  # Por defecto usa el nombre del modelo sin módulo (Manager::Service -> 'service').
+  # Puedes forzarlo con:
+  # self.param_key = 'docker_service'
 end
 ```
 
-### Consumiendo el Servicio (CRUD)
+### CRUD RESTful
 
-La API simula ActiveRecord. Por debajo, construye una "URL" en el header `type` para que el consumidor sepa qué hacer.
+Las operaciones de Ruby se traducen a verbos HTTP sobre AMQP.
 
 ```ruby
-# --- READ (Colección con Filtros) ---
-# Header Type: "users/index?active=true" (Query Params)
-# Routing Key: "users.index" (Dinámico) o "manager_queue" (Estático)
-users = RemoteUser.where(active: true)
-
-# --- READ (Singular) ---
-# Header Type: "users/show/123" (ID en Path)
-# Routing Key: "users.show.123" (Dinámico) o "manager_queue" (Estático)
-user = RemoteUser.find(123)
-puts user.name # Acceso dinámico a atributos
-
-# --- CREATE ---
-# Header Type: "users/create"
-user = RemoteUser.create(email: "test@test.com")
-
-# --- UPDATE ---
-# Header Type: "users/update/123"
-user.update(email: "edit@test.com") 
-# Dirty Tracking: Solo se envían los atributos modificados.
-
-# --- DESTROY ---
-# Header Type: "users/destroy/123"
-user.destroy
+# --- LEER (GET) ---
+# Envia: GET services
+# Routing Key: "services"
+services = Manager::Service.all
+
+# Envia: GET services/123
+service = Manager::Service.find('123')
+
+# --- CREAR (POST) ---
+# Envia: POST services
+# Body: { "service": { "name": "nginx", "replicas": 3 } }
+# Nota: Envuelve los params automáticamente en la clave 'service'.
+svc = Manager::Service.create(name: 'nginx', replicas: 3)
+
+# --- ACTUALIZAR (PUT) ---
+# Envia: PUT services/123
+# Body: { "service": { "replicas": 5 } }
+svc.update(replicas: 5)
+
+# --- ELIMINAR (DELETE) ---
+# Envia: DELETE services/123
+svc.destroy
 ```
 
----
-
-## 🔌 Modo Publisher (Cliente Manual)
-
-Si no necesitas mapear un recurso o quieres enviar mensajes crudos ("Fire-and-Forget"), puedes usar `BugBunny::Client` directamente.
-
-### 1. Instanciar el Cliente
-
-```ruby
-# Puedes inyectar middlewares personalizados aquí si lo deseas
-client = BugBunny::Client.new(pool: BUG_BUNNY_POOL) do |conn|
-  conn.use BugBunny::Middleware::JsonResponse
-end
-```
+### Contexto Dinámico (`.with`)
 
-### 2. Publicar Asíncronamente (Fire-and-Forget)
-Envía el mensaje y retorna inmediatamente. Ideal para eventos o logs.
+Puedes cambiar la configuración (Routing Key, Exchange) para una operación específica sin afectar al modelo global. El contexto se mantiene durante el ciclo de vida del objeto.
 
 ```ruby
-# publish(url_logica, opciones)
-client.publish('notifications/alert', 
-  exchange: 'events.topic', 
-  exchange_type: 'topic',
-  routing_key: 'alerts.critical',
-  body: { message: 'CPU High', server: 'web-1' }
-)
-```
+# La instancia nace sabiendo que pertenece a la routing_key 'urgent'
+svc = Manager::Service.with(routing_key: 'urgent').new(name: 'redis')
 
-### 3. Petición Síncrona (RPC)
-Envía el mensaje y bloquea el hilo esperando la respuesta del consumidor.
+# ... lógica de negocio ...
 
-```ruby
-begin
-  # request(url_logica, opciones)
-  response = client.request('math/calculate', 
-    exchange: 'rpc.direct', 
-    routing_key: 'calculator',
-    body: { a: 10, b: 20 },
-    timeout: 5 # Segundos de espera máxima
-  )
-  
-  puts response['body'] # => { "result": 30 }
-
-rescue BugBunny::RequestTimeout
-  puts "El servidor tardó demasiado."
-end
+# Al guardar, BugBunny recuerda el contexto y envía a 'urgent'
+svc.save
+# Log: [BugBunny] [POST] '/services' | Routing Key: 'urgent'
 ```
 
 ---
 
-## 📡 Modo Servidor (El Worker)
+## 📡 Modo Servidor (Worker & Router)
 
-BugBunny incluye un **Router Inteligente** que parsea el header `type` (la URL simulada), extrae parámetros y despacha al controlador.
+BugBunny incluye un **Router Inteligente** que despacha mensajes a controladores basándose en el Verbo y el Path, imitando a Rails.
 
-### 1. Definir Controladores
+### 1. El Controlador (`app/rabbit/controllers/`)
 
-Crea tus controladores en `app/rabbit/controllers/`. Heredan de `BugBunny::Controller`.
+Hereda de `BugBunny::Controller`. Tienes acceso a `params`, `before_action` y `rescue_from`.
 
 ```ruby
-# app/rabbit/controllers/users_controller.rb
-class UsersController < BugBunny::Controller
+# app/rabbit/controllers/services_controller.rb
+class ServicesController < BugBunny::Controller
+  # Callbacks
+  before_action :set_service, only: %i[show update destroy]
 
-  # Acción para type: "users/index?active=true"
+  # GET services
   def index
-    # params fusiona Query Params y Body
-    users = User.where(active: params[:active])
-    render status: 200, json: users
+    render status: 200, json: DockerService.all
   end
 
-  # Acción para type: "users/show/12"
-  def show
-    # params[:id] se extrae automáticamente del Path de la URL
-    user = User.find_by(id: params[:id])
-    
-    if user
-      render status: 200, json: user
-    else
-      render status: 404, json: { error: 'Not Found' }
-    end
+  # POST services
+  def create
+    # BugBunny wrappea los params automáticamente en el Resource.
+    # Aquí los consumimos con seguridad usando Strong Parameters simulados o hash access.
+    # params[:service] estará disponible gracias al param_key del Resource.
+
+    result = DockerService.create(params[:service])
+    render status: 201, json: result
   end
 
-  # Acción para type: "users/create"
-  def create
-    user = User.new(params)
-    if user.save
-      render status: 201, json: user
-    else
-      # Estos errores se propagan como BugBunny::UnprocessableEntity
-      render status: 422, json: { errors: user.errors }
+  private
+
+  def set_service
+    # params[:id] se extrae automágicamente de la URL (Route Param)
+    @service = DockerService.find(params[:id])
+
+    unless @service
+      render status: 404, json: { error: "Service not found" }
     end
   end
 end
 ```
 
-### 2. Ejecutar el Worker
+### 2. Manejo de Errores (`rescue_from`)
 
-```bash
-bundle exec rake bug_bunny:work
-```
+Puedes definir un `ApplicationController` base para manejar errores de forma centralizada y declarativa.
 
----
+```ruby
+# app/rabbit/controllers/application.rb
+class ApplicationController < BugBunny::Controller
+  # Manejo específico
+  rescue_from ActiveRecord::RecordNotFound do
+    render status: :not_found, json: { error: "Resource missing" }
+  end
 
-## 🏗 Arquitectura REST-over-AMQP
+  rescue_from ActiveModel::ValidationError do |e|
+    render status: :unprocessable_entity, json: e.model.errors
+  end
 
-BugBunny desacopla el transporte de la lógica usando headers.
+  # Catch-all (Red de seguridad)
+  rescue_from StandardError do |e|
+    BugBunny.configuration.logger.error(e)
+    render status: :internal_server_error, json: { error: "Internal Error" }
+  end
+end
+```
 
-| Concepto | REST (HTTP) | BugBunny (AMQP) | Configuración |
+### 3. Tabla de Ruteo (Convención)
+
+El Router infiere la acción automáticamente:
+
+| Verbo | URL Pattern | Controlador | Acción |
 | :--- | :--- | :--- | :--- |
-| **Endpoint** | URL Path (`/users/1`) | Header `type` (`users/show/1`) | `resource_name` |
-| **Filtros** | Query String (`?active=true`) | Header `type` (`users/index?active=true`) | Automático (`where`) |
-| **Destino Físico** | IP/Dominio | Routing Key (`users.create` o `manager`) | `routing_key` (Estático) o `resource_name` (Dinámico) |
-| **Payload** | Body (JSON) | Body (JSON) | N/A |
-| **Status** | HTTP Code (200, 404) | JSON Response `status` | N/A |
+| `GET` | `services` | `ServicesController` | `index` |
+| `GET` | `services/12` | `ServicesController` | `show` |
+| `POST` | `services` | `ServicesController` | `create` |
+| `PUT` | `services/12` | `ServicesController` | `update` |
+| `DELETE` | `services/12` | `ServicesController` | `destroy` |
+| `POST` | `services/12/restart` | `ServicesController` | `restart` (Custom) |
 
 ---
 
-## 🛠 Middlewares
+## 🔌 Modo Publisher (Cliente Manual)
 
-BugBunny usa una pila de middlewares para procesar respuestas.
+Si necesitas enviar mensajes crudos fuera de la lógica Resource, usa `BugBunny::Client`.
 
 ```ruby
-# Configuración global en el Resource
-BugBunny::Resource.client_middleware do |conn|
-  # 1. Lanza excepciones Ruby para errores 4xx/5xx
-  conn.use BugBunny::Middleware::RaiseError
+client = BugBunny::Client.new(pool: BUG_BUNNY_POOL)
+
+# --- REQUEST (Síncrono / RPC) ---
+# Espera la respuesta. Lanza BugBunny::RequestTimeout si falla.
+response = client.request('services/123/logs',
+  method: :get,
+  exchange: 'logs_exchange',
+  timeout: 5
+)
+puts response['body']
 
-  # 2. Parsea JSON a HashWithIndifferentAccess
-  conn.use BugBunny::Middleware::JsonResponse
-end
+# --- PUBLISH (Asíncrono / Fire-and-Forget) ---
+# No espera respuesta.
+client.publish('audit/events',
+  method: :post,
+  body: { event: 'login', user_id: 1 }
+)
 ```
 
-### Excepciones
+---
+
+## 🏗 Arquitectura REST-over-AMQP
+
+BugBunny desacopla el transporte de la lógica usando headers estándar.
+
+1.  **Semántica:** El mensaje lleva headers `type` (URL) y `x-http-method` (Verbo).
+2.  **Ruteo:** El consumidor lee estos headers y ejecuta el controlador correspondiente.
+3.  **Parametros:** `params` unifica:
+    * **Route Params:** `services/123` -> `params[:id] = 123`
+    * **Query Params:** `services?force=true` -> `params[:force] = true`
+    * **Body:** Payload JSON fusionado en el hash.
 
-* `BugBunny::UnprocessableEntity` (422): Error de validación.
-* `BugBunny::NotFound` (404): Recurso no encontrado.
-* `BugBunny::RequestTimeout`: Timeout RPC.
-* `BugBunny::CommunicationError`: Fallo de red RabbitMQ.
+### Logs Estructurados
+
+Facilita el debugging mostrando claramente qué recurso se está tocando y por dónde viaja.
+
+```text
+[BugBunny] [POST] '/services' | Exchange: 'cluster' (Type: direct) | Routing Key: 'node-1'
+```
 
 ---
 

data/lib/bug_bunny/client.rb

@@ -4,31 +4,25 @@ require_relative 'middleware/stack'
 module BugBunny
   # Cliente principal para realizar peticiones a RabbitMQ.
   #
-  # Implementa el patrón "Onion Middleware" (Arquitectura de Cebolla) similar a Faraday,
-  # permitiendo interceptar, transformar y procesar tanto las peticiones salientes
-  # como las respuestas entrantes mediante una pila de middlewares.
+  # Implementa el patrón "Onion Middleware" (Arquitectura de Cebolla) similar a Faraday.
+  # Mantiene una interfaz flexible donde el verbo HTTP se pasa como opción.
   #
-  # @example Inicialización básica
-  #   client = BugBunny::Client.new(pool: MY_POOL)
+  # @example Petición RPC (GET)
+  #   client.request('users/123', method: :get)
   #
-  # @example Con Middlewares personalizados
-  #   client = BugBunny::Client.new(pool: MY_POOL) do |conn|
-  #     conn.use BugBunny::Middleware::RaiseError
-  #     conn.use BugBunny::Middleware::JsonResponse
-  #     conn.use BugBunny::Middleware::Logger, Rails.logger
-  #   end
+  # @example Publicación Fire-and-Forget (POST)
+  #   client.publish('logs', method: :post, body: { msg: 'Error' })
   class Client
     # @return [ConnectionPool] El pool de conexiones subyacente a RabbitMQ.
     attr_reader :pool
 
-    # @return [BugBunny::Middleware::Stack] La pila de middlewares configurada para este cliente.
+    # @return [BugBunny::Middleware::Stack] La pila de middlewares configurada.
     attr_reader :stack
 
     # Inicializa un nuevo cliente.
     #
     # @param pool [ConnectionPool] Pool de conexiones a RabbitMQ configurado previamente.
     # @yield [stack] Bloque opcional para configurar la pila de middlewares.
-    # @yieldparam stack [BugBunny::Middleware::Stack] El objeto stack para registrar middlewares con {#use}.
     # @raise [ArgumentError] Si no se proporciona un `pool`.
     def initialize(pool:)
       raise ArgumentError, "BugBunny::Client requiere un 'pool:'" if pool.nil?
@@ -39,21 +33,16 @@ module BugBunny
 
     # Realiza una petición Síncrona (RPC / Request-Response).
     #
-    # Envía un mensaje y bloquea la ejecución del hilo actual hasta recibir una respuesta
-    # correlacionada del servidor o hasta que se supere el tiempo de espera (timeout).
+    # Envía un mensaje y bloquea la ejecución del hilo actual hasta recibir respuesta.
     #
-    # @param url [String] La ruta o acción del mensaje (ej: 'users/create').
-    # @param args [Hash] Opciones de configuración de la petición.
-    # @option args [Object] :body El cuerpo del mensaje (Hash o String).
-    # @option args [String] :exchange Nombre del exchange destino.
-    # @option args [String] :exchange_type Tipo de exchange ('direct', 'topic', 'fanout').
-    # @option args [String] :routing_key Routing key manual (opcional).
-    # @option args [Integer] :timeout Tiempo máximo de espera en segundos antes de lanzar timeout.
-    # @option args [Hash] :headers Headers AMQP adicionales para metadatos.
-    # @yield [req] Bloque opcional para configurar el objeto Request directamente.
-    # @yieldparam req [BugBunny::Request] Objeto request configurable.
-    # @return [Hash] La respuesta del servidor, conteniendo habitualmente `status` y `body`.
-    # @raise [BugBunny::RequestTimeout] Si no se recibe respuesta en el tiempo límite.
+    # @param url [String] La ruta del recurso (ej: 'users/1').
+    # @param args [Hash] Opciones de configuración.
+    # @option args [Symbol] :method El verbo HTTP (:get, :post, :put, :delete). Default: :get.
+    # @option args [Object] :body El cuerpo del mensaje.
+    # @option args [Hash] :headers Headers AMQP adicionales.
+    # @option args [Integer] :timeout Tiempo máximo de espera.
+    # @yield [req] Bloque para configurar el objeto Request directamente.
+    # @return [Hash] La respuesta del servidor.
     def request(url, **args)
       run_in_pool(:rpc, url, args) do |req|
         yield req if block_given?
@@ -62,13 +51,9 @@ module BugBunny
 
     # Realiza una publicación Asíncrona (Fire-and-Forget).
     #
-    # Envía el mensaje al exchange y retorna el control inmediatamente sin esperar
-    # ninguna confirmación o respuesta del consumidor.
-    #
-    # @param url [String] La ruta o acción del mensaje.
-    # @param args [Hash] Mismas opciones que {#request}, excepto `:timeout` (no aplica).
-    # @yield [req] Bloque opcional para configurar el objeto Request.
-    # @yieldparam req [BugBunny::Request] Objeto request configurable.
+    # @param url [String] La ruta del evento/recurso.
+    # @param args [Hash] Mismas opciones que {#request}, excepto `:timeout`.
+    # @yield [req] Bloque para configurar el objeto Request.
     # @return [void]
     def publish(url, **args)
       run_in_pool(:fire, url, args) do |req|
@@ -78,16 +63,14 @@ module BugBunny
 
     private
 
-    # Ejecuta la lógica de envío dentro del contexto del Pool y aplica la cadena de middlewares.
-    #
-    # @param method_name [Symbol] El método a invocar en el Producer (:rpc o :fire).
-    # @param url [String] La URL/Acción del request.
-    # @param args [Hash] Argumentos pasados al método público.
+    # Ejecuta la lógica de envío dentro del contexto del Pool.
+    # Mapea los argumentos al objeto Request y ejecuta la cadena de middlewares.
     def run_in_pool(method_name, url, args)
       # 1. Builder del Request
       req = BugBunny::Request.new(url)
 
       # 2. Syntactic Sugar: Mapeo de argumentos a atributos del Request
+      req.method        = args[:method]        if args[:method]
       req.body          = args[:body]          if args[:body]
       req.exchange      = args[:exchange]      if args[:exchange]
       req.exchange_type = args[:exchange_type] if args[:exchange_type]

data/lib/bug_bunny/config.rb

@@ -26,6 +26,10 @@ module BugBunny
     # @return [Logger] Instancia del logger para depuración (default: Logger a STDOUT).
     attr_accessor :logger
 
+    # @return [Logger] Logger específico para el driver Bunny (Conexión, Heartbeats, Frames).
+    # Se recomienda nivel WARN para evitar ruido.
+    attr_accessor :bunny_logger
+
     # @return [Boolean] Si `true`, Bunny intentará reconectar automáticamente ante fallos de red (default: true).
     attr_accessor :automatically_recover
 
@@ -58,7 +62,13 @@ module BugBunny
 
     # Inicializa la configuración con valores por defecto seguros.
     def initialize
+      # Logger de la Aplicación (BugBunny) -> INFO (Ves tus requests)
       @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+
+      # Logger del Driver (Bunny) -> WARN (Oculta el ruido de "handle_frame")
+      @bunny_logger = Logger.new(STDOUT)
+      @bunny_logger.level = Logger::WARN
       @automatically_recover = true
       @network_recovery_interval = 5
       @connection_timeout = 10