bug_bunny 3.0.6 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a8a31414070c751adbf073b7588e31d866ed7f1047abfbadad6de2ae75e411e
-  data.tar.gz: 438a1f9d2a2d3cd6f012f16a5c1349c42f20c87be1cb76212a841c528004bdfd
+  metadata.gz: fc4ecbe75edaf8811acfe2929b74fb4aa98cb65c61d74aca4f5a1320b40a94b8
+  data.tar.gz: c3ed5b1e5a773ab8d80fbecc1b96d4a04a62dd1f0b1b5414a2275f497fcde9ee
 SHA512:
-  metadata.gz: 130ae01d89317ad8ecf2c9bb832d4ce235f6eb23df903e256ea47a5669bc2b300239b41beabcbb6a2e8dc44a674ac3eaa90cb8fab0bc44037c377e1503317022
-  data.tar.gz: 603106d7e627b086624d88914601b6cdeb465162116cb6821ca519b5a75c20b7700a0a7ee578e44ef3b311784f69bc17efea1e73a7d32403e5c19efb6b21836a
+  metadata.gz: ee79317a849f3b62e25791f8c3e2bc73e55e6531c697f04ef7896ff438bfac817c5efef15f170769fc3c441a212776f6cec90d0a02b7a52764208512862df1af
+  data.tar.gz: a4e7c0a8a5661e285978376b12c13977fcb9c522a4a19b8c15177d81917084dde7b595baa30c8ef142547d2e35a5983abec7ccaf2a8b6a52e044e51b8196889f

data/CHANGELOG.md

@@ -1,4 +1,32 @@
 # Changelog
+## [3.1.1] - 2026-02-19
+
+### 🚀 Features
+* **Infrastructure Configuration Cascade:** Added support for dynamic configuration of RabbitMQ Exchanges and Queues (e.g., `durable`, `auto_delete`). Configurations can now be applied across 3 levels:
+  1. **Global Default:** Via `BugBunny.configure { |c| c.exchange_options = {...} }`.
+  2. **Resource Level:** Via class attributes `self.exchange_options = {...}` on `BugBunny::Resource`.
+  3. **On-the-fly:** Via `BugBunny::Client` request kwargs or `Resource.with(exchange_options: {...})`.
+
+### 🛠 Improvements
+* **Test Suite Resilience:** Updated internal test helpers to use global cascade configurations, resolving `PRECONDITION_FAILED` conflicts during rapid test execution.
+
+## [3.1.0] - 2026-02-18
+
+### 🌟 New Features: Observability & Tracing
+* **Distributed Tracing Stack:** Implemented a native distributed tracing system that ensures full visibility from the Producer to the Consumer/Worker.
+    * **Producer:** Messages now automatically carry a `correlation_id`. Added support for custom Middlewares to inject IDs from the application context (e.g., Rails `Current.request_id` or Sidekiq IDs).
+    * **Consumer:** Automatically extracts the `correlation_id` from AMQP headers and wraps the entire execution in a **Tagged Logger** block (e.g., `[d41d8cd9...] [API] Processing...`).
+    * **Controller:** Introduced `self.log_tags` to allow injecting rich business context into logs (e.g., `[Tenant-123]`) using the native `around_action` hook.
+
+### 🛡 Security
+* **Router Hardening:** Added a strict inheritance check in the `Consumer`.
+    * **Prevention:** The router now verifies that the instantiated class inherits from `BugBunny::Controller` before execution.
+    * **Impact:** Prevents potential **Remote Code Execution (RCE)** vulnerabilities where an attacker could try to instantiate arbitrary system classes (like `::Kernel`) via the `type` header.
+
+### 🐛 Bug Fixes
+* **RPC Type Consistency:** Fixed a critical issue where RPC responses were ignored if the `correlation_id` was an Integer.
+    * **Fix:** The Producer now strictly normalizes all correlation IDs to Strings (`.to_s`) during both storage (pending requests) and retrieval (reply listener), ensuring reliable matching regardless of the ID format.
+
 ## [3.0.6] - 2026-02-17
 
 ### ♻️ Refactor & Standards

data/README.md

@@ -1,8 +1,39 @@
 # 🐰 BugBunny
 
-**BugBunny** es un framework RPC para Ruby on Rails sobre **RabbitMQ**.
+[![Gem Version](https://badge.fury.io/rb/bug_bunny.svg)](https://badge.fury.io/rb/bug_bunny)
 
-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.
+**Active Record over AMQP.**
+
+BugBunny transforma la complejidad de la mensajería asíncrona (RabbitMQ) en una arquitectura **RESTful familiar** para desarrolladores Rails. Envía mensajes como si estuvieras usando Active Record y procésalos como si fueran Controladores de Rails.
+
+---
+
+## 📖 Tabla de Contenidos
+- [Introducción: La Filosofía](#-introducción-la-filosofía)
+- [Instalación](#-instalación)
+- [Configuración Inicial](#-configuración-inicial)
+- [Configuración de Infraestructura en Cascada](#-configuración-de-infraestructura-en-cascada-nuevo-v31)
+- [Modo Cliente: Recursos (ORM)](#-modo-cliente-recursos-orm)
+    - [Definición y Atributos](#1-definición-y-atributos-híbridos)
+    - [CRUD y Consultas](#2-crud-y-consultas-restful)
+    - [Contexto Dinámico (.with)](#3-contexto-dinámico-with)
+    - [Client Middleware](#4-client-middleware-interceptores)
+- [Modo Servidor: Controladores](#-modo-servidor-controladores)
+    - [Ruteo Inteligente](#1-ruteo-inteligente)
+    - [El Controlador](#2-el-controlador)
+    - [Manejo de Errores](#3-manejo-de-errores-declarativo)
+- [Observabilidad y Tracing](#-observabilidad-y-tracing)
+- [Guía de Producción](#-guía-de-producción)
+
+---
+
+## 💡 Introducción: La Filosofía
+
+En lugar de pensar en "Exchanges" y "Queues", BugBunny inyecta verbos HTTP (`GET`, `POST`, `PUT`, `DELETE`) y rutas (`users/1`) en los headers de AMQP.
+
+* **Tu código (Cliente):** `User.create(name: 'Gabi')`
+* **Protocolo (BugBunny):** Envía `POST /users` (Header `type: users`) vía RabbitMQ.
+* **Worker (Servidor):** Recibe el mensaje y ejecuta `UsersController#create`.
 
 ---
 
@@ -11,271 +42,296 @@ Su filosofía es **"Active Record over AMQP"**. Transforma la complejidad de la
 Agrega la gema a tu `Gemfile`:
 
 ```ruby
-gem 'bug_bunny'
+gem 'bug_bunny', '~> 3.1'
 ```
 
-Ejecuta el bundle:
+Ejecuta el bundle e instala los archivos base:
 
 ```bash
 bundle install
-```
-
-Genera los archivos de configuración iniciales:
-
-```bash
 rails g bug_bunny:install
 ```
 
-Esto creará:
+Esto genera:
 1.  `config/initializers/bug_bunny.rb`
 2.  `app/rabbit/controllers/`
 
 ---
 
-## ⚙️ Configuración
+## ⚙️ Configuración Inicial
 
-### 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.
+Para entornos productivos (Puma/Sidekiq), es **obligatorio** configurar un Pool de conexiones.
 
 ```ruby
 # config/initializers/bug_bunny.rb
 
 BugBunny.configure do |config|
-  # --- Credenciales ---
+  # 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', '/')
 
-  # --- Timeouts ---
-  config.rpc_timeout = 10               # Timeout para esperar respuesta (Síncrono)
-  config.network_recovery_interval = 5  # Segundos para reintentar conexión
+  # 2. Timeouts y Recuperación
+  config.rpc_timeout = 10               # Segundos máx para esperar respuesta (Síncrono)
+  config.network_recovery_interval = 5  # Reintento de conexión
 
-  # --- Logging (Niveles recomendados) ---
-  # Logger de BugBunny: Muestra tus requests (INFO)
-  config.logger = Logger.new(STDOUT)
-  config.logger.level = Logger::INFO
+  # 3. Logging
+  config.logger = Rails.logger
+end
 
-  # Logger de Bunny (Driver): Silencia el ruido de bajo nivel (WARN)
-  config.bunny_logger = Logger.new(STDOUT)
-  config.bunny_logger.level = Logger::WARN
+# 4. 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
 ```
 
-### 2. Connection Pool (Crítico) 🧵
+---
+
+## 🏗️ Configuración de Infraestructura en Cascada (Nuevo v3.1)
+
+BugBunny v3.1 introduce un sistema de configuración jerárquico para los parámetros de RabbitMQ (como la durabilidad de Exchanges y Colas). Las opciones se resuelven en el siguiente orden de prioridad:
 
-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.
+1.  **Defaults de la Gema:** Rápidos y efímeros (`durable: false`).
+2.  **Configuración Global:** Definida en el inicializador para todo el entorno.
+3.  **Configuración de Recurso:** Atributos de clase en modelos específicos.
+4.  **Configuración al Vuelo:** Parámetros pasados en la llamada `.with` o en el Cliente manual.
+
+**Ejemplo de Configuración Global (Nivel 2):**
+Útil para hacer que todos los recursos en el entorno de pruebas sean auto-borrables.
 
 ```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
+BugBunny.configure do |config|
+  if Rails.env.test?
+    config.exchange_options = { auto_delete: true }
+    config.queue_options    = { auto_delete: true }
+  end
 end
-
-# Inyecta el pool a los recursos para que lo usen automáticamente
-BugBunny::Resource.connection_pool = BUG_BUNNY_POOL
 ```
 
 ---
 
-## 🚀 Modo Resource (ORM / Cliente)
+## 🚀 Modo Cliente: Recursos (ORM)
 
-Define modelos que actúan como proxies de recursos remotos. BugBunny se encarga de serializar, "wrappear" parámetros y enviar el verbo correcto.
+Los recursos son proxies de servicios remotos. Heredan de `BugBunny::Resource`.
 
-### Definición del Modelo
+### 1. Definición y Atributos Híbridos
+BugBunny v3 es **Schema-less**. Soporta atributos tipados (ActiveModel) y dinámicos simultáneamente, además de definir su propia infraestructura.
 
 ```ruby
 # app/models/manager/service.rb
 class Manager::Service < BugBunny::Resource
-  # 1. Configuración de Transporte
-  self.exchange = 'box_cluster_manager'
-  self.exchange_type = 'direct'
+  # 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 }
 
-  # 2. Configuración Lógica (Routing)
-  # Define la URL base y la routing key por defecto.
+  # Configuración de Ruteo (La "URL" base)
   self.resource_name = 'services'
 
-  # 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'
+  # 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
 ```
 
-### CRUD RESTful
-
-Las operaciones de Ruby se traducen a verbos HTTP sobre AMQP.
+### 2. CRUD y Consultas RESTful
 
 ```ruby
 # --- LEER (GET) ---
-# Envia: GET services
-# Routing Key: "services"
-services = Manager::Service.all
-
+# 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) ---
-# Envia: POST services
-# Body: { "service": { "name": "nginx", "replicas": 3 } }
-# Nota: Envuelve los params automáticamente en la clave 'service'.
+# 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) ---
-# Envia: PUT services/123
-# Body: { "service": { "replicas": 5 } }
-svc.update(replicas: 5)
+# Dirty Tracking: Solo envía los campos que cambiaron.
+svc.name = 'nginx-pro'
+svc.save
 
 # --- ELIMINAR (DELETE) ---
-# Envia: DELETE services/123
 svc.destroy
 ```
 
-### Contexto Dinámico (`.with`)
-
-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.
+### 3. Contexto Dinámico (`.with`)
+Puedes sobrescribir la configuración de enrutamiento o infraestructura para una ejecución específica sin afectar al modelo global (Thread-Safe).
 
 ```ruby
-# La instancia nace sabiendo que pertenece a la routing_key 'urgent'
-svc = Manager::Service.with(routing_key: 'urgent').new(name: 'redis')
+# 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')
+```
 
-# ... lógica de negocio ...
+### 4. Client Middleware (Interceptores)
+Intercepta peticiones antes de salir hacia RabbitMQ. Ideal para inyectar Auth o Headers.
 
-# Al guardar, BugBunny recuerda el contexto y envía a 'urgent'
-svc.save
-# Log: [BugBunny] [POST] '/services' | Routing Key: 'urgent'
+```ruby
+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
 ```
 
 ---
 
-## 📡 Modo Servidor (Worker & Router)
+## 📡 Modo Servidor: Controladores
 
-BugBunny incluye un **Router Inteligente** que despacha mensajes a controladores basándose en el Verbo y el Path, imitando a Rails.
+BugBunny implementa un **Router** que despacha mensajes a controladores basándose en el header `type` (URL) y `x-http-method`.
 
-### 1. El Controlador (`app/rabbit/controllers/`)
+### 1. Ruteo Inteligente
+El consumidor infiere automáticamente la acción:
 
-Hereda de `BugBunny::Controller`. Tienes acceso a `params`, `before_action` y `rescue_from`.
+| Verbo AMQP | Path (Header `type`) | Controlador | Acción |
+| :--- | :--- | :--- | :--- |
+| `GET` | `services` | `ServicesController` | `index` |
+| `GET` | `services/123` | `ServicesController` | `show` |
+| `POST` | `services` | `ServicesController` | `create` |
+| `PUT` | `services/123` | `ServicesController` | `update` |
+| `DELETE` | `services/123` | `ServicesController` | `destroy` |
+| `POST` | `services/123/restart` | `ServicesController` | `restart` (Custom) |
+
+### 2. El Controlador
+Ubicación: `app/rabbit/controllers/`.
 
 ```ruby
-# app/rabbit/controllers/services_controller.rb
 class ServicesController < BugBunny::Controller
-  # Callbacks
-  before_action :set_service, only: %i[show update destroy]
+  # Callbacks estándar
+  before_action :set_service, only: [:show, :update]
 
-  # GET services
-  def index
-    render status: 200, json: DockerService.all
+  def show
+    # Renderiza JSON que viajará de vuelta por la cola reply-to
+    render status: 200, json: { id: @service.id, state: 'running' }
   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
+    # BugBunny envuelve los params automáticamente (param_key)
+    # 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] 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
+    # params[:id] se extrae del Path
+    @service = Service.find(params[:id])
   end
 end
 ```
 
-### 2. Manejo de Errores (`rescue_from`)
-
-Puedes definir un `ApplicationController` base para manejar errores de forma centralizada y declarativa.
+### 3. Manejo de Errores Declarativo
+Captura excepciones y devuélvelas como códigos de estado AMQP/HTTP.
 
 ```ruby
-# app/rabbit/controllers/application.rb
 class ApplicationController < BugBunny::Controller
-  # Manejo específico
-  rescue_from ActiveRecord::RecordNotFound do
+  rescue_from ActiveRecord::RecordNotFound do |e|
     render status: :not_found, json: { error: "Resource missing" }
   end
 
-  rescue_from ActiveModel::ValidationError do |e|
-    render status: :unprocessable_entity, json: e.model.errors
-  end
-
-  # Catch-all (Red de seguridad)
   rescue_from StandardError do |e|
     BugBunny.configuration.logger.error(e)
-    render status: :internal_server_error, json: { error: "Internal Error" }
+    render status: :internal_server_error, json: { error: "Crash" }
   end
 end
 ```
 
-### 3. Tabla de Ruteo (Convención)
+---
 
-El Router infiere la acción automáticamente:
+## 🔎 Observabilidad y Tracing
 
-| Verbo | URL Pattern | Controlador | Acción |
-| :--- | :--- | :--- | :--- |
-| `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) |
+> **Novedad v3.1:** BugBunny implementa Distributed Tracing nativo.
 
----
+El `correlation_id` se mantiene intacto a través de toda la cadena: `Producer -> RabbitMQ -> Consumer -> Controller`.
+
+### 1. Logs Automáticos (Consumer)
+No requiere configuración. El worker envuelve la ejecución en bloques de log etiquetados con el UUID.
 
-## 🔌 Modo Publisher (Cliente Manual)
+```text
+[d41d8cd9...] [Consumer] Listening on queue...
+[d41d8cd9...] [API] Processing ServicesController#create...
+```
 
-Si necesitas enviar mensajes crudos fuera de la lógica Resource, usa `BugBunny::Client`.
+### 2. Logs de Negocio (Controller)
+Inyecta contexto rico (Tenant, Usuario, IP) en los logs usando `log_tags`.
 
 ```ruby
-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']
-
-# --- PUBLISH (Asíncrono / Fire-and-Forget) ---
-# No espera respuesta.
-client.publish('audit/events',
-  method: :post,
-  body: { event: 'login', user_id: 1 }
-)
+# 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
 ```
 
----
+### 3. Inyección en el Productor
+Para que tus logs de Rails y Rabbit coincidan, usa un middleware global:
 
-## 🏗 Arquitectura REST-over-AMQP
+```ruby
+# 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 desacopla el transporte de la lógica usando headers estándar.
+BugBunny::Client.prepend(Module.new {
+  def initialize(pool:)
+    super
+    @stack.use CorrelationInjector
+  end
+})
+```
 
-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.
+---
 
-### Logs Estructurados
+## 🧵 Guía de Producción
 
-Facilita el debugging mostrando claramente qué recurso se está tocando y por dónde viaja.
+### Connection Pooling
+Es vital usar `ConnectionPool` si usas servidores web multi-hilo (Puma) o workers (Sidekiq). BugBunny no gestiona hilos internamente; se apoya en el pool.
 
-```text
-[BugBunny] [POST] '/services' | Exchange: 'cluster' (Type: direct) | Routing Key: 'node-1'
-```
+### Fork Safety
+BugBunny incluye un `Railtie` que detecta automáticamente cuando Rails hace un "Fork" (ej: Puma en modo Cluster o Spring). Desconecta automáticamente las conexiones heredadas para evitar corrupción de datos en los sockets TCP.
+
+### RPC y "Direct Reply-To"
+Para máxima velocidad, BugBunny usa `amq.rabbitmq.reply-to`.
+* **Trade-off:** Si el cliente (Rails) se reinicia justo después de enviar un mensaje RPC pero antes de recibir la respuesta, esa respuesta se pierde.
+* **Recomendación:** Diseña tus acciones RPC (`POST`, `PUT`) para que sean **idempotentes** (seguras de reintentar ante un timeout).
+
+### Seguridad
+El Router incluye protecciones contra **Remote Code Execution (RCE)**. Verifica estrictamente que la clase instanciada herede de `BugBunny::Controller` antes de ejecutarla, impidiendo la inyección de clases arbitrarias de Ruby vía el header `type`.
 
 ---
 

data/Rakefile

@@ -1,8 +1,12 @@
-# frozen_string_literal: true
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
-require "bundler/gem_tasks"
-require "rubocop/rake_task"
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+  t.warning = false
+end
 
-RuboCop::RakeTask.new
-
-task default: :rubocop
+task default: :test

data/lib/bug_bunny/client.rb

@@ -1,14 +1,16 @@
-# lib/bug_bunny/client.rb
+# frozen_string_literal: true
+
 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.
-  # Mantiene una interfaz flexible donde el verbo HTTP se pasa como opción.
+  # Mantiene una interfaz flexible donde el verbo HTTP se pasa como opción y permite
+  # configurar la infraestructura AMQP de forma granular por petición.
   #
-  # @example Petición RPC (GET)
-  #   client.request('users/123', method: :get)
+  # @example Petición RPC (GET) con opciones de infraestructura
+  #   client.request('users/123', method: :get, exchange_options: { durable: true })
   #
   # @example Publicación Fire-and-Forget (POST)
   #   client.publish('logs', method: :post, body: { msg: 'Error' })
@@ -41,6 +43,8 @@ module BugBunny
     # @option args [Object] :body El cuerpo del mensaje.
     # @option args [Hash] :headers Headers AMQP adicionales.
     # @option args [Integer] :timeout Tiempo máximo de espera.
+    # @option args [Hash] :exchange_options Opciones específicas para la declaración del Exchange.
+    # @option args [Hash] :queue_options Opciones específicas para la declaración de la Cola.
     # @yield [req] Bloque para configurar el objeto Request directamente.
     # @return [Hash] La respuesta del servidor.
     def request(url, **args)
@@ -65,18 +69,28 @@ module BugBunny
 
     # Ejecuta la lógica de envío dentro del contexto del Pool.
     # Mapea los argumentos al objeto Request y ejecuta la cadena de middlewares.
+    #
+    # @param method_name [Symbol] El método del productor a llamar (:rpc o :fire).
+    # @param url [String] La ruta destino.
+    # @param args [Hash] Argumentos pasados a los métodos públicos.
+    # @yield [req] Bloque para configuración adicional del Request.
     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]
-      req.routing_key   = args[:routing_key]   if args[:routing_key]
-      req.timeout       = args[:timeout]       if args[:timeout]
-      req.headers.merge!(args[:headers])       if args[:headers]
+      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]
+      req.routing_key      = args[:routing_key]      if args[:routing_key]
+      req.timeout          = args[:timeout]          if args[:timeout]
+
+      # Inyección de opciones de infraestructura (Nivel 3 de la cascada)
+      req.exchange_options = args[:exchange_options] if args[:exchange_options]
+      req.queue_options    = args[:queue_options]    if args[:queue_options]
+
+      req.headers.merge!(args[:headers])             if args[:headers]
 
       # 3. Configuración del usuario (bloque específico por request)
       yield req if block_given?
@@ -94,6 +108,7 @@ module BugBunny
           app = @stack.build(final_action)
           app.call(req)
         ensure
+          # Aseguramos el cierre del canal pero mantenemos la conexión del pool
           session.close
         end
       end