bug_bunny 2.0.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fccb3590fd16133119a7e2cea4c05002964846ac5a35e0714925f2d87115a06
-  data.tar.gz: 839ab64bb406eebee8e59f99c010c640a033dab15cd0f531e66f0fbc1e201c82
+  metadata.gz: 0e154bfecb70c1fc85408e87876976dfc8c64c01c2816c4f811a05e39e8432f9
+  data.tar.gz: 3b4e1508cd1a7f019fb638831c58117d00c46729b4f6bad4f8ecaf1b75914b47
 SHA512:
-  metadata.gz: 4be8016e660aec70394814ffc85ecba71759aeb94df817abac412c201685ebee89c447fdd76b9904dfb5d2bc5f73e208ed0eed2d9bbc016a307c09978254c76e
-  data.tar.gz: 741552a099ae0aadb5717cb46fc4ff24c77c9f31f7dae677131dc158f784a75bca1a739bb6cf65eba42bff84fba853d25a2df54ca0d5884a23f679fa72c679b0
+  metadata.gz: b43ec72552e6d17601665f7640aedd1e9c390463f6df5ca950b082e17316e387d0a10fa9e5ddfd3611d3f928a5d7d2af71367fa6c5409ba1f242402bd46843a1
+  data.tar.gz: cdd64f5401a653a0fe839ea2a3cf926e1af7de6e8498892bbd20876ea2ed808f97d4db1daa1a31f70c54533a00f73e834a547943d34f8a95543b1befeb5a9591

data/CHANGELOG.md

@@ -1,3 +1,25 @@
 # Changelog
+
+## [3.0.0] - 2026-02-05
+
+### ⚠ Breaking Changes
+* **Architecture Overhaul:** Complete rewrite implementing the "Active Record over AMQP" philosophy. The framework now simulates a RESTful architecture where messages contain "URLs" (via `type` header) that map to Controllers.
+* **Resource Configuration:** Removed `routing_key_prefix` in favor of `resource_name`. By default, `resource_name` is now automatically pluralized (Rails-style) to determine routing keys and headers.
+* **Schema-less Resources:** Removed strict `ActiveModel::Attributes` dependency. `BugBunny::Resource` no longer requires defining attributes manually. It now uses a dynamic storage (`@remote_attributes`) supporting arbitrary keys (including PascalCase for Docker APIs) via `method_missing`.
+
+### 🚀 New Features
+* **Middleware Stack:** Implemented an "Onion Architecture" for the `Client` similar to Faraday. Added support for middleware chains to intercept requests/responses.
+    * `Middleware::JsonResponse`: Automatically parses JSON bodies and provides `IndifferentAccess`.
+    * `Middleware::RaiseError`: Maps AMQP/HTTP status codes to Ruby exceptions (e.g., 404 to `BugBunny::NotFound`).
+* **REST-over-AMQP Routing:** The `Consumer` now parses the `type` header as a URL (e.g., `users/show/12?active=true`) to dispatch actions to specific Controllers.
+* **Direct Reply-To RPC:** Optimized RPC calls to use RabbitMQ's native `amq.rabbitmq.reply-to` feature, eliminating the need for temporary reply queues and improving performance.
+* **Config Inheritance:** `BugBunny::Resource` configurations (like `connection_pool`, `exchange`) are now inherited by child classes, simplifying setup for groups of models.
+
+### 🛠 Improvements
+* **Connection Pooling:** Full integration with `connection_pool` to ensure thread safety in multi-threaded environments (Puma/Sidekiq).
+* **Error Handling:** Unified exception hierarchy under `BugBunny::Error`, with specific classes for Client (4xx) and Server (5xx) errors.
+* **Rails Integration:** Added `Railtie` with hooks for Puma and Spring to safely handle connection forks.
+* **Documentation:** Added comprehensive YARD documentation for all core classes.
+
 ## Version 0.1.0
-Migration bunny logic from utils
+* Migration bunny logic from utils

data/README.md

@@ -1,183 +1,273 @@
-# BugBunny
+# 🐰 BugBunny
 
-## Configuration
+**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.
+
+---
+
+## 📦 Instalación
+
+Agrega la gema a tu `Gemfile`:
 
 ```ruby
-config/initializers/bug_bunny.rb
-BugBunny.configure do |config|
-  config.host = 'Host'
-  config.username = 'Username'
-  config.password = 'Password'
-  config.vhost = '/'
-  config.logger = Rails.logger
-  config.automatically_recover = false
-  config.network_recovery_interval = 5
-  config.connection_timeout = 10
-  config.read_timeout = 30
-  config.write_timeout = 30
-  config.heartbeat = 15
-  config.continuation_timeout = 15_000
-end
+gem 'bug_bunny'
 ```
 
-## Publish
-
-### Rutas
+Ejecuta el bundle:
 
+```bash
+bundle install
 ```
-# config/rabbit_rest.yml
-default: &default
-  healt_check:
-    up: 'healt_check/up'
-  manager:
-      services:
-        index: 'services/index'
-        create: 'services/create'
-        show: 'services/%<id>s/show'
-        update: 'services/%<id>s/update'
-        destroy: 'services/%<id>s/destroy'
-      swarm:
-        info: 'swarm/info'
-        version: 'swarm/version'
-        swarm: 'swarm/swarm'
-      tasks:
-        index: 'tasks/index'
-
-development:
-  <<: *default
-
-test:
-  <<: *default
-
-production:
-  <<: *default
 
+Corre el instalador para generar la configuración:
+
+```bash
+rails g bug_bunny:install
 ```
 
-### Configuration
+---
+
+## ⚙️ Configuración
+
+Configura tus credenciales y el Pool de conexiones en el inicializador.
 
 ```ruby
 # config/initializers/bug_bunny.rb
-BUG_BUNNY_ENDPOINTS = Rails.application.config_for(:rabbit_rest)
 
-BUNNY_POOL = ConnectionPool.new(size: RABBIT_MAX_THREADS) do
-  BugBunny::Rabbit.create_connection(host: RABBIT_HOST, username: RABBIT_USER, password: RABBIT_PASS, vhost: RABBIT_VIRTUAL_HOST)
+BugBunny.configure do |config|
+  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
 end
+
+# Definimos el Pool Global (Vital para 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
+BugBunny::Resource.connection_pool = BUG_BUNNY_POOL
 ```
 
-### Publisher
+---
 
-Creamos cualquier clase que herede de `BugBunny::Publisher`, luego definimos metodos de clase y dentro de cada una de ella su implementacion
+## 🚀 Modo Resource (ORM / Active Record)
 
-1. Mensajes sincronicos
+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).
 
+### 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`.
+
+```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
 ```
-class Rabbit::Publisher::Manager < BugBunny::Publisher
-  ROUTING_KEY = :manager
-  ROUTES = BUG_BUNNY_ENDPOINTS[:manager][:swarm]
 
-  def self.info(exchange:, message: nil)
-    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:info], message: message)
-    obj.publish_and_consume!
-  end
+### 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.
 
-  def self.version(exchange:, message: nil)
-    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:version], message: message)
-    obj.publish_and_consume!
-  end
+```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'
 end
 ```
 
-2. Mensajes Asincronicos
+### Consumiendo el Servicio (CRUD)
+
+La API simula ActiveRecord. Por debajo, construye una "URL" en el header `type` para que el consumidor sepa qué hacer.
 
+```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
 ```
-class Rabbit::Publisher::Manager < BugBunny::Publisher
-  ROUTING_KEY = :manager
-  ROUTES = BUG_BUNNY_ENDPOINTS[:manager][:swarm]
 
-  def self.info(exchange:, message: nil)
-    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:info], message: message)
-    obj.publish!
-  end
+---
 
-  def self.version(exchange:, message: nil)
-    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:version], message: message)
-    obj.publish!
-  end
+## 🔌 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
 ```
 
-3. Attributes del objeto BugBunny::Publisher
-
-- content_type
-- content_encoding
-- correlation_id
-- reply_to
-- message_id
-- timestamp
-- priority
-- expiration
-- user_id
-- app_id
-- action
-- aguments
-- cluster_id
-- persistent
-- expiration
-
-## Consumer
+### 2. Publicar Asíncronamente (Fire-and-Forget)
+Envía el mensaje y retorna inmediatamente. Ideal para eventos o logs.
 
+```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' }
+)
 ```
-class Rabbit::Controllers::Application < BugBunny::Controller
+
+### 3. Petición Síncrona (RPC)
+Envía el mensaje y bloquea el hilo esperando la respuesta del consumidor.
+
+```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
+```
+
+---
 
-class Rabbit::Controllers::Swarm < Rabbit::Controllers::Application
-  def info
-    render status: :ok, json: Api::Docker.info
+## 📡 Modo Servidor (El Worker)
+
+BugBunny incluye un **Router Inteligente** que parsea el header `type` (la URL simulada), extrae parámetros y despacha al controlador.
+
+### 1. Definir Controladores
+
+Crea tus controladores en `app/rabbit/controllers/`. Heredan de `BugBunny::Controller`.
+
+```ruby
+# app/rabbit/controllers/users_controller.rb
+class UsersController < BugBunny::Controller
+
+  # Acción para type: "users/index?active=true"
+  def index
+    # params fusiona Query Params y Body
+    users = User.where(active: params[:active])
+    render status: 200, json: users
   end
 
-  def version
-    render status: :ok, json: Api::Docker.version
+  # 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
   end
 
-  def swarm
-    render status: :ok, json: Api::Docker.swarm
+  # 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 }
+    end
   end
 end
-
 ```
 
-## Resource
-Solo para recursos que se adaptan al crud de rails estoy utilizando automaticamente la logica de los publicadores. Los atributos solo se ponen si son necesarios, si no la dejas vacia y actua igual que active resource.
+### 2. Ejecutar el Worker
 
+```bash
+bundle exec rake bug_bunny:work
 ```
-class Manager::Application < BugBunny::Resource
-  self.resource_path = 'rabbit/publisher/manager'
-
-  attribute :id         # 'ID'
-  attribute :version    # 'Version'
-  attribute :created_at # 'CreatedAt'
-  attribute :update_at  # 'UpdatedAt'
-  attribute :spec       # 'Spec'
-end
 
-class Manager::Service < Manager::Application
-  attribute :endpoint # 'Endpoint'
-end
+---
+
+## 🏗 Arquitectura REST-over-AMQP
+
+BugBunny desacopla el transporte de la lógica usando headers.
+
+| Concepto | REST (HTTP) | BugBunny (AMQP) | Configuració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 |
+
+---
+
+## 🛠 Middlewares
+
+BugBunny usa una pila de middlewares para procesar respuestas.
 
+```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
+
+  # 2. Parsea JSON a HashWithIndifferentAccess
+  conn.use BugBunny::Middleware::JsonResponse
+end
 ```
 
-## Exceptions
-- Error General:
- - `BugBunny::Error` hereda de `::StandardError` (Captura cualquier error de la gema.)
-- Error de Publicadores:
- - `BugBunny::PublishError` hereda de `BugBunny::Error` (Para fallos de envío o conexión.)
-- Error de Respuestas:
- - `BugBunny::ResponseError::Base` hereda de `BugBunny::Error` (Captura todos los errores de respuesta).
-- Errores Específicos de Respuesta:
- - `BugBunny::ResponseError::BadRequest`
- - `BugBunny::ResponseError::NotFound`
- - `BugBunny::ResponseError::NotAcceptable`
- - `BugBunny::ResponseError::RequestTimeout`
- - `BugBunny::ResponseError::UnprocessableEntity`: En este el error viene el error details a lo rails.
- - `BugBunny::ResponseError::InternalServerError`
+### Excepciones
+
+* `BugBunny::UnprocessableEntity` (422): Error de validación.
+* `BugBunny::NotFound` (404): Recurso no encontrado.
+* `BugBunny::RequestTimeout`: Timeout RPC.
+* `BugBunny::CommunicationError`: Fallo de red RabbitMQ.
+
+---
+
+## 📄 Licencia
+
+Código abierto bajo [MIT License](https://opensource.org/licenses/MIT).

data/bin_client.rb

@@ -0,0 +1,51 @@
+# bin_client.rb
+require_relative 'lib/bug_bunny'
+$stdout.sync = true # <--- Agrega esto
+
+# 1. Configuración
+BugBunny.configure do |config|
+  config.host = 'localhost'
+  config.username = 'wisproMQ'
+  config.password = 'wisproMQ'
+  config.vhost = 'sync.devel'
+  config.logger = Logger.new(STDOUT)
+  config.rpc_timeout = 5
+end
+
+# 2. Pool
+POOL = ConnectionPool.new(size: 2, timeout: 5) do
+  BugBunny.create_connection
+end
+
+# 3. Cliente
+client = BugBunny.new(pool: POOL)
+
+# --- PRUEBA 1: Publish ---
+puts "\n[1] Enviando mensaje asíncrono (Publish)..."
+
+# AGREGADO: exchange_type: 'topic'
+client.publish('test/ping', exchange: 'test_exchange', exchange_type: 'topic', routing_key: 'test.ping') do |req|
+  req.body = { msg: 'Hola, soy invisible' }
+end
+
+puts "    -> Enviado."
+sleep 1
+
+# --- PRUEBA 2: RPC ---
+puts "\n[2] Enviando petición síncrona (Request)..."
+
+begin
+  # AGREGADO: exchange_type: 'topic'
+  response = client.request('test/123/ping', exchange: 'test_exchange', exchange_type: 'topic', routing_key: 'test.ping') do |req|
+    req.body = { data: 'Importante' }
+    req.timeout = 3
+    req.headers['X-Source'] = 'Terminal'
+  end
+
+  puts "    -> ✅ RESPUESTA RECIBIDA:"
+  puts "       Status: #{response['status']}"
+  puts "       Body:   #{response['body']}"
+
+rescue BugBunny::RequestTimeout
+  puts "    -> ❌ Error: Timeout esperando respuesta."
+end

data/bin_suite.rb

@@ -0,0 +1,77 @@
+# bin_suite.rb
+require_relative 'test_helper'
+require_relative 'test_resource' # Cargamos la clase TestUser
+
+# Cliente "Raw" para pruebas manuales
+raw_client = BugBunny.new(pool: TEST_POOL)
+
+def assert(condition, msg)
+  if condition
+    puts "  ✅ PASS: #{msg}"
+  else
+    puts "  ❌ FAIL: #{msg}"
+  end
+end
+
+puts "\n🔎 --- INICIANDO SUITE DE PRUEBAS BUG BUNNY ---"
+
+# ---------------------------------------------------------
+# TEST 1: RPC Manual (Raw Client)
+# ---------------------------------------------------------
+puts "\n[1] Probando RPC Manual (Client#request)..."
+begin
+  # Notar la routing key: test_user.ping
+  response = raw_client.request('test_user/ping', exchange: 'test_exchange', exchange_type: 'topic', routing_key: 'test_user.ping')
+  assert(response['body']['message'] == 'Pong!', "Respuesta RPC recibida correctamente")
+rescue => e
+  assert(false, "Error RPC: #{e.message}")
+end
+
+# ---------------------------------------------------------
+# TEST 2: Resource Finder (ORM)
+# ---------------------------------------------------------
+puts "\n[2] Probando BugBunny::Resource (Estilo Rails)..."
+
+# YA NO NECESITAS with_scope
+puts "    -> Buscando usuario ID 123..."
+user = TestUser.find(123)
+
+assert(user.is_a?(TestUser), "El objeto retornado es un TestUser")
+assert(user.name == "Gabriel", "El nombre cargó correctamente")
+assert(user.persisted?, "El objeto figura como persistido")
+# ---------------------------------------------------------
+# TEST 3: Resource Create (ORM)
+# ---------------------------------------------------------
+puts "\n[3] Probando Resource Creation..."
+puts "    -> Creando usuario nuevo..."
+new_user = TestUser.create(name: "Nuevo User", email: "new@test.com")
+assert(new_user.persisted?, "El usuario se guardó y recibió ID")
+assert(new_user.id.present?, "Tiene ID asignado por el worker (#{new_user.id})")
+
+# ---------------------------------------------------------
+# TEST 4: Validaciones Locales
+# ---------------------------------------------------------
+puts "\n[4] Probando Validaciones Locales..."
+invalid_user = TestUser.new(email: "sin_nombre@test.com")
+assert(invalid_user.valid? == false, "Usuario sin nombre es inválido")
+assert(invalid_user.errors[:name].any?, "Tiene error en el campo :name")
+
+puts "\n🏁 SUITE FINALIZADA"
+
+# ---------------------------------------------------------
+# TEST 5: Probando Configuración Dinámica (.with)...
+# ---------------------------------------------------------
+puts "\n[5] Probando Configuración Dinámica (.with)..."
+
+# Probamos cambiar el routing key prefix temporalmente
+# El worker escucha 'test_user.*', así que si cambiamos a 'bad_prefix', debería fallar o no encontrar nada
+begin
+  # Forzamos una routing key que no existe para ver si respeta el cambio
+  TestUser.with(routing_key: 'ruta.incorrecta').find(123)
+rescue BugBunny::RequestTimeout
+  puts "  ✅ PASS: El override funcionó (timeout esperado en ruta incorrecta)"
+end
+
+# Probamos que vuelve a la normalidad
+user = TestUser.find(123)
+assert(user.present?, "  ✅ PASS: La configuración volvió a la normalidad")

data/bin_worker.rb

@@ -0,0 +1,20 @@
+# bin_worker.rb
+require_relative 'test_helper'
+require_relative 'test_controller'
+
+puts "🐰 WORKER INICIADO (Exchange: Topic)..."
+
+# Creamos la conexión (o usamos una del pool si quisieras)
+connection = BugBunny.create_connection
+
+# Usamos el método de clase directo.
+# Al no pasar 'block: false', esto bloqueará la ejecución aquí mismo eternamente.
+BugBunny::Consumer.subscribe(
+  connection: connection,
+  queue_name: 'test_users_queue',
+  exchange_name: 'test_exchange',
+  exchange_type: 'topic',
+  routing_key: 'test_user.#'
+)
+
+# ¡Ya no necesitas el loop! El subscribe mantiene vivo el proceso.

data/initializer_example.rb

@@ -0,0 +1,27 @@
+# config/initializers/bug_bunny.rb
+
+# 1. Configuración Global de Conexión (Credenciales)
+BugBunny.configure do |config|
+  config.host = ENV.fetch('RABBITMQ_HOST', 'localhost')
+  config.vhost = ENV.fetch('RABBITMQ_VHOST', '/')
+  config.username = ENV.fetch('RABBITMQ_USER', 'guest')
+  config.password = ENV.fetch('RABBITMQ_PASS', 'guest')
+  config.logger = Rails.logger
+end
+
+# 2. Crear el Pool de Conexiones (Vital para Puma/Sidekiq)
+# Usamos una constante global o un singleton para mantener el pool vivo
+BUG_BUNNY_POOL = ConnectionPool.new(size: ENV.fetch('RAILS_MAX_THREADS', 5).to_i, timeout: 5) do
+  BugBunny.create_connection
+end
+
+# 3. Inyectar el Pool en los Recursos
+# Así todos tus modelos (User, Invoice, etc.) usan este pool por defecto
+BugBunny::Resource.connection_pool = BUG_BUNNY_POOL
+
+# 4. (Opcional) Configurar Middlewares Globales
+# Si en el futuro quieres que BugBunny::Resource use middlewares (logs, tracing),
+# podrías inyectar un cliente pre-configurado en lugar del pool directo.
+# Por ahora, con el pool es suficiente para la v1.0.
+
+puts "🐰 BugBunny inicializado con Pool de #{BUG_BUNNY_POOL.size} conexiones."