bug_bunny 3.0.4 → 3.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4752202964e5f4382a685a356a31264db3ae51049c42a49d3e5a6602fda10ed1
-  data.tar.gz: 1cb2f414e1fb52560d9a4310fd0679c1a59f86dc072fce6dd385b17006ecc6a0
+  metadata.gz: 0a8a31414070c751adbf073b7588e31d866ed7f1047abfbadad6de2ae75e411e
+  data.tar.gz: 438a1f9d2a2d3cd6f012f16a5c1349c42f20c87be1cb76212a841c528004bdfd
 SHA512:
-  metadata.gz: 74af2e635f79d182cfe0fc336a67bf5175ad02729e39b5ddb77fb6bfdde4e3e733f863c78e453160ca6e03ff381dc81f1169a1c9d7be39a116d971638f61d846
-  data.tar.gz: c7da63dcce1cc2f0b77faa253327ddb4eec88866328429e84383172e07be402ff9d9c2ca6a2fbe16e9c0f7762bd8119c17496caa37a4ad35d0be07867e8aa78c
+  metadata.gz: 130ae01d89317ad8ecf2c9bb832d4ce235f6eb23df903e256ea47a5669bc2b300239b41beabcbb6a2e8dc44a674ac3eaa90cb8fab0bc44037c377e1503317022
+  data.tar.gz: 603106d7e627b086624d88914601b6cdeb465162116cb6821ca519b5a75c20b7700a0a7ee578e44ef3b311784f69bc17efea1e73a7d32403e5c19efb6b21836a

data/CHANGELOG.md

@@ -1,4 +1,21 @@
 # Changelog
+## [3.0.6] - 2026-02-17
+
+### ♻️ Refactor & Standards
+* **Architectural Cleanup:** Removed the `BugBunny::Rabbit` intermediate class. Connection management logic (`disconnect`) has been moved directly to the main `BugBunny` module for simplicity.
+* **Rails Standardization:** Renamed `lib/bug_bunny/config.rb` to `lib/bug_bunny/configuration.rb` and the class from `Config` to `Configuration`. This ensures full compliance with Zeitwerk autoloading standards.
+
+### 🛡 Stability
+* **Fork Safety:** Enhanced `Railtie` to robustly handle process forking. Added support for `ActiveSupport::ForkTracker` (Rails 7.1+) and guarded Puma event hooks to prevent `NoMethodError` on newer Puma versions.
+
+## [3.0.5] - 2026-02-17
+
+### 🐛 Bug Fixes
+* **Load Error Resolution:** Fixed `TypeError: Middleware is not a module` by converting `BugBunny::Middleware` into a proper module and introducing `BugBunny::Middleware::Base`.
+
+### 🛠 Improvements
+* **Standardized Middleware Architecture:** Consolidated the Template Method pattern across all internal interceptors (`RaiseError`, `JsonResponse`).
+
 ## [3.0.4] - 2026-02-16
 
 ### ♻️ Refactoring & Architecture

data/bin_worker.rb

@@ -1,20 +1,26 @@
+# frozen_string_literal: true
+
 # bin_worker.rb
-require_relative 'test_helper'
-require_relative 'test_controller'
+require 'bundler/setup'
+require 'bug_bunny'
+require_relative 'test_controller' # Cargamos los controladores
+
+puts '🐰 WORKER INICIADO (Exchange: Topic)...'
 
-puts "🐰 WORKER INICIADO (Exchange: Topic)..."
+# Configuración básica
+BugBunny.configure do |config|
+  config.logger = Logger.new($stdout)
+  config.logger.level = Logger::DEBUG
+end
 
-# Creamos la conexión (o usamos una del pool si quisieras)
+# Iniciar el Consumidor
+# Escucha en la cola 'bug_bunny_queue', atada al exchange 'test_exchange' con routing key '#' (todo)
 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.#'
+  queue_name: 'bug_bunny_test_queue',
+  routing_key: '#' # Wildcard para recibir todo en este test
 )
-
-# ¡Ya no necesitas el loop! El subscribe mantiene vivo el proceso.

data/lib/bug_bunny/{config.rb → configuration.rb}

@@ -1,19 +1,17 @@
-# lib/bug_bunny/config.rb
+# frozen_string_literal: true
+
 require 'logger'
 
 module BugBunny
   # Clase de configuración global para la gema BugBunny.
   # Almacena las credenciales de conexión, timeouts y parámetros de ajuste de RabbitMQ.
-  #
-  # @example Configuración típica
-  #   BugBunny.configure do |config|
-  #     config.host = 'rabbit.local'
-  #     config.rpc_timeout = 5
-  #   end
-  class Config
+  class Configuration
     # @return [String] Host o IP del servidor RabbitMQ (ej: 'localhost').
     attr_accessor :host
 
+    # @return [Integer] Puerto del servidor RabbitMQ (default: 5672).
+    attr_accessor :port
+
     # @return [String] Usuario para la autenticación (default: 'guest').
     attr_accessor :username
 
@@ -26,48 +24,51 @@ 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.
+    # @return [Logger] Logger específico para el driver Bunny.
     attr_accessor :bunny_logger
 
-    # @return [Boolean] Si `true`, Bunny intentará reconectar automáticamente ante fallos de red (default: true).
+    # @return [Boolean] Si `true`, Bunny intentará reconectar automáticamente.
     attr_accessor :automatically_recover
 
-    # @return [Integer] Tiempo en segundos a esperar antes de intentar reconectar (default: 5).
+    # @return [Integer] Tiempo en segundos a esperar antes de intentar reconectar.
     attr_accessor :network_recovery_interval
 
-    # @return [Integer] Timeout en segundos para establecer la conexión TCP inicial (default: 10).
+    # @return [Integer] Timeout en segundos para establecer la conexión TCP inicial.
     attr_accessor :connection_timeout
 
-    # @return [Integer] Timeout en segundos para leer datos del socket TCP (default: 30).
+    # @return [Integer] Timeout en segundos para leer datos del socket TCP.
     attr_accessor :read_timeout
 
-    # @return [Integer] Timeout en segundos para escribir datos en el socket TCP (default: 30).
+    # @return [Integer] Timeout en segundos para escribir datos en el socket TCP.
     attr_accessor :write_timeout
 
-    # @return [Integer] Intervalo en segundos para enviar latidos (heartbeats) y mantener la conexión viva (default: 15).
+    # @return [Integer] Intervalo en segundos para enviar latidos (heartbeats).
     attr_accessor :heartbeat
 
-    # @return [Integer] Timeout en milisegundos para operaciones de continuación RPC internas de Bunny (default: 15_000).
+    # @return [Integer] Timeout en milisegundos para operaciones de continuación RPC internas.
     attr_accessor :continuation_timeout
 
-    # @return [Integer] Cantidad de mensajes que el consumidor pre-cargará antes de procesarlos (QoS) (default: 1).
+    # @return [Integer] Cantidad de mensajes que el consumidor pre-cargará (QoS).
     attr_accessor :channel_prefetch
 
-    # @return [Integer] Tiempo máximo en segundos que el cliente esperará una respuesta RPC antes de lanzar {BugBunny::RequestTimeout} (default: 10).
+    # @return [Integer] Tiempo máximo en segundos que el cliente esperará una respuesta RPC.
     attr_accessor :rpc_timeout
 
-    # @return [Integer] Intervalo en segundos para verificar que la cola del consumidor sigue existiendo (default: 60).
+    # @return [Integer] Intervalo en segundos para verificar la salud de la cola.
     attr_accessor :health_check_interval
 
     # 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)
+      @host = '127.0.0.1' # Valor por defecto explícito
+      @port = 5672        # <--- AGREGADO (Default RabbitMQ Port)
+      @username = 'guest'
+      @password = 'guest'
+      @vhost = '/'
+
+      @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 = Logger.new($stdout)
       @bunny_logger.level = Logger::WARN
       @automatically_recover = true
       @network_recovery_interval = 5
@@ -82,11 +83,8 @@ module BugBunny
     end
 
     # Construye la URL de conexión AMQP basada en los atributos configurados.
-    # Útil para logs o herramientas externas.
-    #
-    # @return [String] La cadena de conexión en formato `amqp://user:pass@host/vhost`.
     def url
-      "amqp://#{username}:#{password}@#{host}/#{vhost}"
+      "amqp://#{username}:#{password}@#{host}:#{port}/#{vhost}"
     end
   end
 end

data/lib/bug_bunny/middleware/base.rb

@@ -0,0 +1,46 @@
+# lib/bug_bunny/middleware.rb
+# frozen_string_literal: true
+
+module BugBunny
+  module Middleware
+    # Clase base para todos los middlewares de BugBunny.
+    #
+    # Implementa el patrón "Template Method" para estandarizar el flujo de ejecución
+    # de la cadena de responsabilidades (Ida y Vuelta).
+    #
+    # Las subclases deben implementar:
+    # * {#on_request} para modificar la petición antes de enviarla.
+    # * {#on_complete} para modificar la respuesta después de recibirla.
+    #
+    # @abstract Subclase y anula {#on_request} o {#on_complete} para inyectar lógica.
+    class Base
+      # @return [Object] El siguiente middleware en la pila o el adaptador final.
+      attr_reader :app
+
+      # Inicializa el middleware.
+      #
+      # @param app [Object] El siguiente eslabón de la cadena.
+      def initialize(app)
+        @app = app
+      end
+
+      # Ejecuta el middleware orquestando los hooks de ciclo de vida.
+      #
+      # 1. Llama a {#on_request} (Ida).
+      # 2. Llama al siguiente eslabón (`@app.call`).
+      # 3. Llama a {#on_complete} (Vuelta).
+      #
+      # @param env [BugBunny::Request] El objeto request (entorno).
+      # @return [Hash] La respuesta final procesada.
+      def call(env)
+        on_request(env) if respond_to?(:on_request)
+
+        response = @app.call(env)
+
+        on_complete(response) if respond_to?(:on_complete)
+
+        response
+      end
+    end
+  end
+end

data/lib/bug_bunny/middleware/json_response.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 require 'json'
-require_relative '../middleware'
+require_relative '../middleware/base'
 
 module BugBunny
   module Middleware
@@ -11,8 +11,8 @@ module BugBunny
     # Convierte strings JSON en Hashes de Ruby. Si está disponible ActiveSupport,
     # aplica HashWithIndifferentAccess.
     #
-    # @see BugBunny::Middleware
-    class JsonResponse < BugBunny::Middleware
+    # @see BugBunny::Middleware::Base
+    class JsonResponse < BugBunny::Middleware::Base
       # Hook de ciclo de vida: Ejecutado después de recibir la respuesta.
       #
       # Intercepta el body y lo reemplaza por su versión parseada.

data/lib/bug_bunny/middleware/raise_error.rb

@@ -1,15 +1,15 @@
 # lib/bug_bunny/middleware/raise_error.rb
 # frozen_string_literal: true
 
-require_relative '../middleware'
+require_relative '../middleware/base'
 
 module BugBunny
   module Middleware
     # Middleware que inspecciona el status de la respuesta y lanza excepciones
     # si se encuentran errores (4xx o 5xx).
     #
-    # @see BugBunny::Middleware
-    class RaiseError < BugBunny::Middleware
+    # @see BugBunny::Middleware::Base
+    class RaiseError < BugBunny::Middleware::Base
       # Hook de ciclo de vida: Ejecutado después de recibir la respuesta.
       #
       # Verifica el código de estado y lanza la excepción correspondiente.

data/lib/bug_bunny/railtie.rb

@@ -1,4 +1,5 @@
-# lib/bug_bunny/railtie.rb
+# frozen_string_literal: true
+
 require 'rails'
 
 module BugBunny
@@ -11,11 +12,7 @@ module BugBunny
   # @see https://guides.rubyonrails.org/engines.html#railtie
   class Railtie < ::Rails::Railtie
     # 1. Configuración de Autoload
-    #
-    # Agrega el directorio `app/rabbit` a los paths de carga automática.
-    # Esto permite que Rails encuentre automáticamente los controladores definidos por el usuario
-    # (ej: `Rabbit::Controllers::Users`) sin necesidad de `require` manuales.
-    initializer "bug_bunny.add_autoload_paths" do |app|
+    initializer 'bug_bunny.add_autoload_paths' do |app|
       rabbit_path = File.join(app.root, 'app', 'rabbit')
       if Dir.exist?(rabbit_path)
         app.config.autoload_paths << rabbit_path
@@ -23,31 +20,29 @@ module BugBunny
       end
     end
 
-    # 2. Hook de Puma (Servidor Web)
+    # 2. Gestión de Forks (Puma / Spring / otros)
     #
-    # Detecta cuando Puma arranca un nuevo "worker" en modo clúster.
     # Es vital cerrar la conexión heredada del proceso padre (Master) antes de que
     # el hijo empiece a trabajar, para evitar compartir el mismo socket TCP.
-    #
-    # La nueva conexión se creará perezosamente (Lazy) cuando el worker la necesite.
     config.after_initialize do
-      if defined?(Puma)
+      # Estrategia 1: Rails 7.1+ ForkTracker (La forma estándar moderna)
+      if defined?(ActiveSupport::ForkTracker)
+        ActiveSupport::ForkTracker.after_fork { BugBunny.disconnect }
+      end
+
+      # Estrategia 2: Hook específico de Puma (Legacy)
+      # Solo intentamos usarlo si la API 'events' está disponible (Puma < 5).
+      if defined?(Puma) && Puma.respond_to?(:events)
         Puma.events.on_worker_boot do
-          BugBunny::Rabbit.disconnect
+          BugBunny.disconnect
         end
       end
     end
 
     # 3. Hook de Spring (Preloader)
-    #
-    # Spring mantiene una instancia de la aplicación en memoria y hace `fork` para
-    # ejecutar comandos (rails c, rspec, etc) rápidamente.
-    #
-    # Al igual que con Puma, debemos desconectar la conexión al RabbitMQ justo después
-    # del fork para asegurar que el nuevo proceso tenga su propio socket limpio.
     if defined?(Spring)
       Spring.after_fork do
-        BugBunny::Rabbit.disconnect
+        BugBunny.disconnect
       end
     end
   end

data/lib/bug_bunny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BugBunny
-  VERSION = "3.0.4"
+  VERSION = "3.0.6"
 end

data/lib/bug_bunny.rb

@@ -1,114 +1,104 @@
+# frozen_string_literal: true
+
 require 'bunny'
 require 'logger'
-require 'connection_pool'
-
 require_relative 'bug_bunny/version'
-require_relative 'bug_bunny/config'
 require_relative 'bug_bunny/exception'
-require_relative 'bug_bunny/request'
+require_relative 'bug_bunny/configuration'
+require_relative 'bug_bunny/middleware/base'
+require_relative 'bug_bunny/middleware/stack'
+require_relative 'bug_bunny/middleware/raise_error'
+require_relative 'bug_bunny/middleware/json_response'
+require_relative 'bug_bunny/client'
 require_relative 'bug_bunny/session'
+require_relative 'bug_bunny/consumer'
+require_relative 'bug_bunny/request'
 require_relative 'bug_bunny/producer'
-require_relative 'bug_bunny/client'
 require_relative 'bug_bunny/resource'
-require_relative 'bug_bunny/rabbit'
-require_relative 'bug_bunny/consumer'
 require_relative 'bug_bunny/controller'
-require_relative 'bug_bunny/middleware'
-
-require_relative 'bug_bunny/middleware/stack'
-require_relative 'bug_bunny/middleware/raise_error'
-require_relative 'bug_bunny/middleware/json_response'
+require_relative 'bug_bunny/railtie' if defined?(Rails)
 
-# Punto de entrada principal y Namespace de la gema BugBunny.
-#
-# BugBunny es un framework ligero sobre RabbitMQ diseñado para simplificar
-# patrones de mensajería (RPC y Fire-and-Forget) en aplicaciones Ruby on Rails.
-#
-# @see BugBunny::Client Para enviar mensajes.
-# @see BugBunny::Resource Para mapear modelos remotos.
-# @see BugBunny::Consumer Para procesar mensajes entrantes.
+# Módulo principal de la gema BugBunny.
+# Actúa como espacio de nombres y punto de configuración global.
 module BugBunny
-  # Factory method (Alias) para instanciar un nuevo Cliente.
-  #
-  # @param args [Hash] Argumentos pasados al constructor de {BugBunny::Client}.
-  # @return [BugBunny::Client] Una nueva instancia del cliente.
-  def self.new(**args)
-    BugBunny::Client.new(**args)
+  class << self
+    # @return [BugBunny::Configuration] La configuración global actual.
+    attr_accessor :configuration
+
+    # @return [Bunny::Session, nil] La conexión global (Singleton) usada por procesos Rails.
+    attr_accessor :global_connection
   end
 
-  # Configura la librería globalmente.
-  #
-  # @example Configuración típica en un initializer
-  #   BugBunny.configure do |config|
-  #     config.host = 'localhost'
-  #     config.username = 'guest'
-  #     config.rpc_timeout = 5
-  #   end
+  # Configura la librería BugBunny.
+  # Si no se ha configurado previamente, inicializa una nueva configuración por defecto.
   #
-  # @yield [config] Bloque de configuración.
-  # @yieldparam config [BugBunny::Config] Objeto de configuración global.
-  # @return [BugBunny::Config] La configuración actualizada.
+  # @yieldparam config [BugBunny::Configuration] El objeto de configuración para modificar.
+  # @return [void]
   def self.configure
-    self.configuration ||= Config.new
+    self.configuration ||= Configuration.new
     yield(configuration)
   end
 
-  # Accesor al objeto de configuración global (Singleton).
+  # Crea e inicia una nueva conexión a RabbitMQ utilizando la gema Bunny.
+  # Mezcla las opciones pasadas explícitamente con la configuración global por defecto.
+  #
+  # @param options [Hash] Opciones de conexión que sobrescriben la configuración global.
+  # @option options [String] :host ('127.0.0.1') Host del servidor RabbitMQ.
+  # @option options [Integer] :port (5672) Puerto del servidor.
+  # @option options [String] :username ('guest') Usuario de conexión.
+  # @option options [String] :password ('guest') Contraseña.
+  # @option options [String] :vhost ('/') Virtual Host.
+  # @option options [Logger] :logger Logger para la conexión interna de Bunny.
+  # @option options [Boolean] :automatically_recover (true) Si debe reconectar automáticamente.
+  # @option options [Integer] :connection_timeout (10) Tiempo de espera para conectar.
+  # @option options [Integer] :read_timeout (10) Tiempo de espera para lectura.
+  # @option options [Integer] :write_timeout (10) Tiempo de espera para escritura.
+  # @option options [Integer] :heartbeat (15) Intervalo de latidos en segundos.
+  # @option options [Integer] :continuation_timeout (15000) Timeout para operaciones RPC internas.
   #
-  # @return [BugBunny::Config] La instancia de configuración actual.
-  def self.configuration
-    @configuration ||= Config.new
+  # @return [Bunny::Session] Una sesión de Bunny ya iniciada (`start` ya invocado).
+  # @raise [Bunny::TCPConnectionFailed] Si no se puede conectar al servidor.
+  def self.create_connection(**options)
+    conn_options = merge_connection_options(options)
+    Bunny.new(conn_options).tap(&:start)
   end
 
-  # Cierra la conexión global mantenida por {BugBunny::Rabbit}.
-  # Útil para liberar recursos en scripts o tareas Rake al finalizar.
+  # Cierra la conexión global si existe.
+  #
+  # Este método es utilizado principalmente por el Railtie para asegurar que
+  # los procesos hijos (forks) de servidores como Puma o Spring no hereden
+  # la conexión TCP del proceso padre, forzando una reconexión limpia ("Lazy").
   #
-  # @see BugBunny::Rabbit.disconnect
   # @return [void]
   def self.disconnect
-    BugBunny::Rabbit.disconnect
-  end
+    return unless @global_connection
 
-  # Crea una nueva conexión a RabbitMQ (Bunny Session).
-  #
-  # Este método fusiona la configuración global por defecto con las opciones
-  # pasadas explícitamente como argumentos, dando prioridad a estas últimas.
-  #
-  # Maneja automáticamente el inicio de la conexión (`start`) y captura errores
-  # de red comunes envolviéndolos en excepciones de BugBunny.
-  #
-  # @param options [Hash] Opciones de conexión que sobrescriben la configuración global.
-  # @option options [String] :host Host de RabbitMQ.
-  # @option options [String] :vhost Virtual Host.
-  # @option options [String] :username Usuario.
-  # @option options [String] :password Contraseña.
-  # @option options [Logger] :logger Logger personalizado.
-  # @option options [Boolean] :automatically_recover (true/false).
-  # @option options [Integer] :network_recovery_interval Intervalo de reconexión.
-  # @option options [Integer] :connection_timeout Timeout de conexión TCP.
-  # @return [Bunny::Session] Una sesión de Bunny iniciada y lista para usar.
-  # @raise [BugBunny::CommunicationError] Si no se puede establecer la conexión TCP.
-  def self.create_connection(**options)
-    default = configuration
+    @global_connection.close if @global_connection.open?
+    @global_connection = nil
+    configuration.logger.info('[BugBunny] Global connection closed.')
+  end
 
-    bunny = Bunny.new(
-      host:                      options[:host]                      || default.host,
-      username:                  options[:username]                  || default.username,
-      password:                  options[:password]                  || default.password,
-      vhost:                     options[:vhost]                     || default.vhost,
-      logger:                    options[:logger]                    || default.bunny_logger,
-      automatically_recover:     options[:automatically_recover]     || default.automatically_recover,
-      network_recovery_interval: options[:network_recovery_interval] || default.network_recovery_interval,
-      connection_timeout:        options[:connection_timeout]        || default.connection_timeout,
-      read_timeout:              options[:read_timeout]              || default.read_timeout,
-      write_timeout:             options[:write_timeout]             || default.write_timeout,
-      heartbeat:                 options[:heartbeat]                 || default.heartbeat,
-      continuation_timeout:      options[:continuation_timeout]      || default.continuation_timeout
-    )
+  # @api private
+  # Fusiona las opciones del usuario con los valores por defecto de la configuración.
+  def self.merge_connection_options(options)
+    # .compact elimina los valores nil de options para no sobrescribir los defaults
+    default_connection_options.merge(options.compact)
+  end
 
-    bunny.start
-    bunny
-  rescue Timeout::Error, Bunny::ConnectionError => e
-    raise BugBunny::CommunicationError, e.message
+  # @api private
+  # Genera el hash de opciones por defecto basado en la configuración global.
+  # Extraído para reducir la métrica AbcSize de merge_connection_options.
+  def self.default_connection_options
+    cfg = configuration || Configuration.new
+    {
+      host: cfg.host, port: cfg.port,
+      username: cfg.username, password: cfg.password, vhost: cfg.vhost,
+      logger: cfg.bunny_logger, automatically_recover: cfg.automatically_recover,
+      connection_timeout: cfg.connection_timeout, read_timeout: cfg.read_timeout,
+      write_timeout: cfg.write_timeout, heartbeat: cfg.heartbeat,
+      continuation_timeout: cfg.continuation_timeout
+    }
   end
+
+  private_class_method :merge_connection_options, :default_connection_options
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 3.0.6
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-16 00:00:00.000000000 Z
+date: 2026-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -196,16 +196,15 @@ files:
 - initializer_example.rb
 - lib/bug_bunny.rb
 - lib/bug_bunny/client.rb
-- lib/bug_bunny/config.rb
+- lib/bug_bunny/configuration.rb
 - lib/bug_bunny/consumer.rb
 - lib/bug_bunny/controller.rb
 - lib/bug_bunny/exception.rb
-- lib/bug_bunny/middleware.rb
+- lib/bug_bunny/middleware/base.rb
 - lib/bug_bunny/middleware/json_response.rb
 - lib/bug_bunny/middleware/raise_error.rb
 - lib/bug_bunny/middleware/stack.rb
 - lib/bug_bunny/producer.rb
-- lib/bug_bunny/rabbit.rb
 - lib/bug_bunny/railtie.rb
 - lib/bug_bunny/request.rb
 - lib/bug_bunny/resource.rb

data/lib/bug_bunny/middleware.rb

@@ -1,44 +0,0 @@
-# lib/bug_bunny/middleware.rb
-# frozen_string_literal: true
-
-module BugBunny
-  # Clase base para todos los middlewares de BugBunny.
-  #
-  # Implementa el patrón "Template Method" para estandarizar el flujo de ejecución
-  # de la cadena de responsabilidades (Ida y Vuelta).
-  #
-  # Las subclases deben implementar:
-  # * {#on_request} para modificar la petición antes de enviarla.
-  # * {#on_complete} para modificar la respuesta después de recibirla.
-  #
-  # @abstract Subclase y anula {#on_request} o {#on_complete} para inyectar lógica.
-  class Middleware
-    # @return [Object] El siguiente middleware en la pila o el adaptador final.
-    attr_reader :app
-
-    # Inicializa el middleware.
-    #
-    # @param app [Object] El siguiente eslabón de la cadena.
-    def initialize(app)
-      @app = app
-    end
-
-    # Ejecuta el middleware orquestando los hooks de ciclo de vida.
-    #
-    # 1. Llama a {#on_request} (Ida).
-    # 2. Llama al siguiente eslabón (`@app.call`).
-    # 3. Llama a {#on_complete} (Vuelta).
-    #
-    # @param env [BugBunny::Request] El objeto request (entorno).
-    # @return [Hash] La respuesta final procesada.
-    def call(env)
-      on_request(env) if respond_to?(:on_request)
-
-      response = @app.call(env)
-
-      on_complete(response) if respond_to?(:on_complete)
-
-      response
-    end
-  end
-end

data/lib/bug_bunny/rabbit.rb

@@ -1,82 +0,0 @@
-# lib/bug_bunny/rabbit.rb
-
-module BugBunny
-  # Clase de soporte e infraestructura para gestionar la conexión global de la aplicación.
-  #
-  # Actúa como un Singleton que mantiene una instancia de `Bunny::Session`.
-  # Es utilizada principalmente por tareas administrativas (Rake tasks), inicializadores
-  # y para lanzar consumidores (Workers).
-  #
-  # @note ¡IMPORTANTE!
-  #   No utilizar esta clase para publicar mensajes desde controladores o servicios web.
-  #   Esta clase mantiene una sola conexión TCP. Para publicar en entornos concurrentes (Puma/Sidekiq),
-  #   se debe utilizar siempre {BugBunny::Client} inyectándole un `ConnectionPool`.
-  class Rabbit
-    class << self
-      # Permite inyectar una conexión manualmente (útil para tests).
-      # @api private
-      attr_writer :connection
-
-      # Obtiene la conexión global actual (Singleton).
-      #
-      # Implementa "Lazy Initialization": si la conexión no existe o está cerrada,
-      # crea una nueva automáticamente.
-      #
-      # @return [Bunny::Session] La sesión cruda de Bunny.
-      def connection
-        return @connection if @connection&.open?
-
-        @connection = create_connection
-      end
-
-      # Crea una nueva conexión utilizando la configuración global de la gema.
-      # Delega la creación al factory principal.
-      #
-      # @see BugBunny.create_connection
-      # @return [Bunny::Session] Una nueva sesión iniciada.
-      def create_connection
-        BugBunny.create_connection
-      end
-
-      # Cierra la conexión global de forma segura.
-      #
-      # Es un método idempotente: verifica si la conexión existe y está abierta antes de intentar cerrarla.
-      # Utilizado comúnmente en los hooks de `at_exit`, o por Railties al recargar código en Spring/Puma.
-      #
-      # @return [void]
-      def disconnect
-        return unless @connection
-
-        @connection.close if @connection.open?
-        @connection = nil
-        BugBunny.configuration.logger.info("[BugBunny] Global connection closed.")
-      end
-
-      # Helper de conveniencia para instanciar y ejecutar un Consumidor (Worker).
-      #
-      # Simplifica el arranque de workers desde tareas Rake, encapsulando la creación
-      # de la instancia {BugBunny::Consumer} y la suscripción.
-      #
-      # @param connection [Bunny::Session] Conexión dedicada para el consumidor (no usar la compartida si es posible).
-      # @param exchange [String] Nombre del exchange.
-      # @param exchange_type [String] Tipo de exchange ('topic', 'direct', etc).
-      # @param queue_name [String] Nombre de la cola.
-      # @param routing_key [String] Routing key para el binding.
-      # @param queue_opts [Hash] Opciones adicionales para la cola (:durable, etc).
-      # @return [void] Este método suele bloquear la ejecución (loop infinito del consumidor).
-      def run_consumer(connection:, exchange:, exchange_type:, queue_name:, routing_key:, queue_opts: {})
-        # 1. Instanciamos el Consumidor (que crea su propia Session interna)
-        consumer = BugBunny::Consumer.new(connection)
-
-        # 2. Iniciamos la suscripción (Bloqueante por defecto)
-        consumer.subscribe(
-          queue_name: queue_name,
-          exchange_name: exchange,
-          exchange_type: exchange_type,
-          routing_key: routing_key,
-          queue_opts: queue_opts
-        )
-      end
-    end
-  end
-end