bug_bunny 4.1.1 → 4.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 599004cdcb498ca746612f60202301ce9783a67ac37d14ecd4c29f51ccaf48bb
-  data.tar.gz: f748ba9a55e91f96a5571f671afa524f7e330cceede0f12c5c7cef6d25d2d2ff
+  metadata.gz: 979c38a4f25c9359afd10b0f3c728b794fdf4dee795adfaea7fd090e832134bc
+  data.tar.gz: 658a0088c4e8cedde115074b81a9247e6cf1c15d226e880c444bd94ed8168cc5
 SHA512:
-  metadata.gz: 7df1503a55cb62d9f87168a84b8e92fe773b4c9525b143d6f848227e66fe63e5ab75f6191a408b00bb9c8840b44c0f8fdbc36cd0a8d2eb56e02018d09654d269
-  data.tar.gz: d5433d839c45ad95a2d0399535ff629112458e90d0e4e1ec89f97afa450b139bcb7855c64c27042c22bce0bde87b2bfa7bd6f8bae5b879dd7eb0c71ff1d20d3c
+  metadata.gz: 0d80a2015e3f26626e6f0261597a261129a4c55f87ed5556f3bab7523327a747e1238241e5c49769f22dd83d231e151913a786b34119eabe43ec858f456c60d1
+  data.tar.gz: 94635e6463d95eac5ffd65e7fe5ff3eaf3c946825052477a31b9ddde0da763b87b5e2f27e877b8c72c5a3bcb13920e28269b12f5c123567bd75ff0ed00d049ae

data/CHANGELOG.md

@@ -1,15 +1,17 @@
 # Changelog
 
+## [4.1.2] - 2026-03-22
+
+### ✨ Improvements
+* **Controller:** Ahora lanza una excepción \`BugBunny::BadRequest\` (400) si el cuerpo de la petición contiene un JSON inválido, mejorando la depuración en el cliente.
+* **Resource:** Se añadió una protección a \`.with\` (\`ScopeProxy\`) para asegurar que el contexto sea de un solo uso, evitando efectos secundarios en llamadas encadenadas.
+
 ## [4.1.1] - 2026-03-22
 
 ### 🐛 Bug Fixes
 * **Consumer:** Previene memory leak al detener el `TimerTask` de health check previo antes de realizar una reconexión.
 * **Controller:** Corrige la mutación accidental de \`log_tags\` globales al usar una lógica de herencia no destructiva en \`compute_tags\`.
 
-### ✨ Improvements
-* **Controller:** Ahora lanza una excepción \`BugBunny::BadRequest\` (400) si el cuerpo de la petición contiene un JSON inválido, mejorando la depuración en el cliente.
-* **Resource:** Se añadió una protección a \`.with\` (\`ScopeProxy\`) para asegurar que el contexto sea de un solo uso, evitando efectos secundarios en llamadas encadenadas.
-
 ## [4.1.0] - 2026-03-22
 
 ### 🚀 New Features & Improvements

data/README.md

@@ -74,7 +74,9 @@ BugBunny.configure do |config|
 
   # 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
+  config.network_recovery_interval = 5  # Base del backoff de reconexión (segundos)
+  config.max_reconnect_interval    = 60 # Techo del backoff exponencial (segundos)
+  config.max_reconnect_attempts    = nil # nil = reintenta infinitamente; Integer = falla hard
 
   # 3. Health Checks (Opcional, para Docker Swarm / K8s)
   config.health_check_file = '/tmp/bug_bunny_health'
@@ -420,6 +422,30 @@ Para máxima velocidad, BugBunny usa `amq.rabbitmq.reply-to`.
 ### Seguridad
 El Router incluye protecciones contra **Remote Code Execution (RCE)**. El Consumer verifica estrictamente que el Controlador resuelto a través del archivo de rutas herede de `BugBunny::Controller` antes de ejecutarla, impidiendo la inyección de clases arbitrarias. Además, las llamadas a rutas no registradas fallan rápido con un `404 Not Found`.
 
+### Reconexión con Backoff Exponencial
+
+Cuando el Consumer pierde la conexión a RabbitMQ, reintenta automáticamente usando un backoff exponencial basado en `network_recovery_interval`:
+
+| Intento | Espera (base = 5s, techo = 60s) |
+|---------|----------------------------------|
+| 1       | 5s                               |
+| 2       | 10s                              |
+| 3       | 20s                              |
+| 4       | 40s                              |
+| 5+      | 60s (cap)                        |
+
+Por defecto reintenta indefinidamente (`max_reconnect_attempts: nil`). En entornos orquestados (Kubernetes, Docker Swarm), es preferible dejar que el orquestador reinicie el contenedor cuando la infraestructura no está disponible:
+
+```ruby
+BugBunny.configure do |config|
+  config.network_recovery_interval = 5   # Base del backoff
+  config.max_reconnect_interval    = 60  # Techo máximo de espera
+  config.max_reconnect_attempts    = 10  # Falla hard después de 10 intentos
+end
+```
+
+Con esta configuración, si RabbitMQ no vuelve en ~10 reintentos el proceso levanta la excepción y el orquestador lo reinicia con su propia política de restart.
+
 ### Health Checks en Docker Swarm / Kubernetes
 Dado que un Worker se ejecuta en segundo plano sin exponer un servidor web tradicional, orquestadores como Docker Swarm o Kubernetes no pueden usar un endpoint HTTP para verificar si el proceso está saludable.
 

data/lib/bug_bunny/configuration.rb

@@ -38,9 +38,16 @@ module BugBunny
     # @return [Boolean] Si `true`, Bunny intentará reconectar automáticamente.
     attr_accessor :automatically_recover
 
-    # @return [Integer] Tiempo en segundos a esperar antes de intentar reconectar.
+    # @return [Integer] Tiempo en segundos a esperar antes de intentar reconectar (base del backoff).
     attr_accessor :network_recovery_interval
 
+    # @return [Integer, nil] Número máximo de intentos de reconexión del Consumer antes de rendirse.
+    #   Si es `nil` (default), reintenta indefinidamente.
+    attr_accessor :max_reconnect_attempts
+
+    # @return [Integer] Techo en segundos para el backoff exponencial de reconexión (default: 60).
+    attr_accessor :max_reconnect_interval
+
     # @return [Integer] Timeout en segundos para establecer la conexión TCP inicial.
     attr_accessor :connection_timeout
 
@@ -106,6 +113,8 @@ module BugBunny
       @bunny_logger.level = Logger::WARN
       @automatically_recover = true
       @network_recovery_interval = 5
+      @max_reconnect_attempts = nil
+      @max_reconnect_interval = 60
       @connection_timeout = 10
       @read_timeout = 30
       @write_timeout = 30

data/lib/bug_bunny/consumer.rb

@@ -43,7 +43,7 @@ module BugBunny
     #
     # @param connection [Bunny::Session] Conexión nativa de Bunny.
     def initialize(connection)
-      @session = BugBunny::Session.new(connection)
+      @session = BugBunny::Session.new(connection, publisher_confirms: false)
       @health_timer = nil
     end
 
@@ -61,41 +61,58 @@ module BugBunny
     # @param block [Boolean] Si es `true`, bloquea el hilo actual (loop infinito).
     # @return [void]
     def subscribe(queue_name:, exchange_name:, routing_key:, exchange_type: 'direct', exchange_opts: {}, queue_opts: {}, block: true)
-      # Declaración de Infraestructura
-      x = session.exchange(name: exchange_name, type: exchange_type, opts: exchange_opts)
-      q = session.queue(queue_name, queue_opts)
-      q.bind(x, routing_key: routing_key)
-
-      # 📊 LOGGING DE OBSERVABILIDAD: Calculamos las opciones finales para mostrarlas en consola
-      final_x_opts = BugBunny::Session::DEFAULT_EXCHANGE_OPTIONS
-                       .merge(BugBunny.configuration.exchange_options || {})
-                       .merge(exchange_opts || {})
-      final_q_opts = BugBunny::Session::DEFAULT_QUEUE_OPTIONS
-                       .merge(BugBunny.configuration.queue_options || {})
-                       .merge(queue_opts || {})
-
-      BugBunny.configuration.logger.info("[BugBunny::Consumer] 🎧 Listening on '#{queue_name}' (Opts: #{final_q_opts})")
-      BugBunny.configuration.logger.info("[BugBunny::Consumer] 🔀 Bounded to Exchange '#{exchange_name}' (#{exchange_type}) | Opts: #{final_x_opts} | RK: '#{routing_key}'")
-
-      start_health_check(queue_name)
-
-      q.subscribe(manual_ack: true, block: block) do |delivery_info, properties, body|
-        trace_id = properties.correlation_id
-
-        logger = BugBunny.configuration.logger
-
-        if logger.respond_to?(:tagged)
-          logger.tagged(trace_id) { process_message(delivery_info, properties, body) }
-        elsif defined?(Rails) && Rails.logger.respond_to?(:tagged)
-          Rails.logger.tagged(trace_id) { process_message(delivery_info, properties, body) }
-        else
-          process_message(delivery_info, properties, body)
+      attempt = 0
+
+      begin
+        # Declaración de Infraestructura
+        x = session.exchange(name: exchange_name, type: exchange_type, opts: exchange_opts)
+        q = session.queue(queue_name, queue_opts)
+        q.bind(x, routing_key: routing_key)
+
+        # 📊 LOGGING DE OBSERVABILIDAD: Calculamos las opciones finales para mostrarlas en consola
+        final_x_opts = BugBunny::Session::DEFAULT_EXCHANGE_OPTIONS
+                         .merge(BugBunny.configuration.exchange_options || {})
+                         .merge(exchange_opts || {})
+        final_q_opts = BugBunny::Session::DEFAULT_QUEUE_OPTIONS
+                         .merge(BugBunny.configuration.queue_options || {})
+                         .merge(queue_opts || {})
+
+        BugBunny.configuration.logger.info("[BugBunny::Consumer] 🎧 Listening on '#{queue_name}' (Opts: #{final_q_opts})")
+        BugBunny.configuration.logger.info("[BugBunny::Consumer] 🔀 Bounded to Exchange '#{exchange_name}' (#{exchange_type}) | Opts: #{final_x_opts} | RK: '#{routing_key}'")
+
+        start_health_check(queue_name)
+
+        q.subscribe(manual_ack: true, block: block) do |delivery_info, properties, body|
+          trace_id = properties.correlation_id
+
+          logger = BugBunny.configuration.logger
+
+          if logger.respond_to?(:tagged)
+            logger.tagged(trace_id) { process_message(delivery_info, properties, body) }
+          elsif defined?(Rails) && Rails.logger.respond_to?(:tagged)
+            Rails.logger.tagged(trace_id) { process_message(delivery_info, properties, body) }
+          else
+            process_message(delivery_info, properties, body)
+          end
+        end
+      rescue StandardError => e
+        attempt += 1
+        max_attempts = BugBunny.configuration.max_reconnect_attempts
+
+        if max_attempts && attempt >= max_attempts
+          BugBunny.configuration.logger.error("[BugBunny::Consumer] 💥 Max reconnect attempts (#{max_attempts}) reached. Giving up: #{e.message}")
+          raise
         end
+
+        wait = [
+          BugBunny.configuration.network_recovery_interval * (2 ** (attempt - 1)),
+          BugBunny.configuration.max_reconnect_interval
+        ].min
+
+        BugBunny.configuration.logger.error("[BugBunny::Consumer] 💥 Connection Error: #{e.message}. Retrying in #{wait}s (attempt #{attempt}/#{max_attempts || '∞'})...")
+        sleep wait
+        retry
       end
-    rescue StandardError => e
-      BugBunny.configuration.logger.error("[BugBunny::Consumer] 💥 Connection Error: #{e.message}. Retrying in #{BugBunny.configuration.network_recovery_interval}s...")
-      sleep BugBunny.configuration.network_recovery_interval
-      retry
     end
 
     private

data/lib/bug_bunny/session.rb

@@ -24,8 +24,12 @@ module BugBunny
     # Inicializa una nueva sesión sin abrir canales todavía.
     #
     # @param connection [Bunny::Session] Una conexión (puede estar abierta o cerrada temporalmente).
-    def initialize(connection)
+    # @param publisher_confirms [Boolean] Si es `true`, el canal se abre en modo Publisher Confirms.
+    #   Activar solo en sesiones de Producer. En sesiones de Consumer genera overhead innecesario
+    #   ya que los replies RPC son fire-and-forget desde la perspectiva del servidor.
+    def initialize(connection, publisher_confirms: true)
       @connection = connection
+      @publisher_confirms = publisher_confirms
       @channel = nil
     end
 
@@ -105,8 +109,7 @@ module BugBunny
     def create_channel!
       @channel = @connection.create_channel
 
-      # Configuraciones globales de BugBunny
-      @channel.confirm_select
+      @channel.confirm_select if @publisher_confirms
 
       if BugBunny.configuration.channel_prefetch
         @channel.prefetch(BugBunny.configuration.channel_prefetch)

data/lib/bug_bunny/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 4.1.1
+  version: 4.1.2
 platform: ruby
 authors:
 - gabix