bug_bunny 4.1.0 → 4.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef1416747a080c5d6af30ac97412688c0419e8b3635b410d93580ad869d78924
-  data.tar.gz: e362258f131a6fefdad0b835a410218e349d8d56966bfef67586dd573375ffcb
+  metadata.gz: 979c38a4f25c9359afd10b0f3c728b794fdf4dee795adfaea7fd090e832134bc
+  data.tar.gz: 658a0088c4e8cedde115074b81a9247e6cf1c15d226e880c444bd94ed8168cc5
 SHA512:
-  metadata.gz: e788b41069a507289245398fc56ab5829df1139665319a254b6136aa26eb44a607b0f7d0843b517f4ed3298095629bed97e64d9aaace5cc81313f4995392d12d
-  data.tar.gz: cfff2337042002bf850200a8b63739502e2c4607d2c26d661756f980cf7c8c8986a96545811c03aba7b8fc3c23fe929e62240f63dada14c55ddb02cd38feda30
+  metadata.gz: 0d80a2015e3f26626e6f0261597a261129a4c55f87ed5556f3bab7523327a747e1238241e5c49769f22dd83d231e151913a786b34119eabe43ec858f456c60d1
+  data.tar.gz: 94635e6463d95eac5ffd65e7fe5ff3eaf3c946825052477a31b9ddde0da763b87b5e2f27e877b8c72c5a3bcb13920e28269b12f5c123567bd75ff0ed00d049ae

data/CHANGELOG.md

@@ -1,5 +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\`.
+
 ## [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,8 @@ 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
 
     # Inicia la suscripción a la cola y comienza el bucle de procesamiento.
@@ -60,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
@@ -244,12 +262,16 @@ module BugBunny
     # @param q_name [String] Nombre de la cola a monitorear.
     # @return [void]
     def start_health_check(q_name)
+      # Detener el timer anterior antes de crear uno nuevo (evita leak en cada retry)
+      @health_timer&.shutdown
+      @health_timer = nil
+
       file_path = BugBunny.configuration.health_check_file
 
       # Toque inicial para indicar al orquestador que el worker arrancó correctamente
       touch_health_file(file_path) if file_path
 
-      Concurrent::TimerTask.new(execution_interval: BugBunny.configuration.health_check_interval) do
+      @health_timer = Concurrent::TimerTask.new(execution_interval: BugBunny.configuration.health_check_interval) do
         # 1. Verificamos la salud de RabbitMQ (si falla, levanta un error y corta la ejecución del bloque)
         session.channel.queue_declare(q_name, passive: true)
 
@@ -258,7 +280,8 @@ module BugBunny
       rescue StandardError => e
         BugBunny.configuration.logger.warn("[BugBunny::Consumer] ⚠️  Queue check failed: #{e.message}. Reconnecting session...")
         session.close
-      end.execute
+      end
+      @health_timer.execute
     end
 
     # Actualiza la fecha de modificación del archivo de health check (touchfile).

data/lib/bug_bunny/controller.rb

@@ -146,11 +146,6 @@ module BugBunny
     def process(body)
       prepare_params(body)
 
-      # Inyección de configuración global de logs si el controlador no define propios
-      if self.class.log_tags.empty? && BugBunny.configuration.log_tags.any?
-        self.class.log_tags = BugBunny.configuration.log_tags
-      end
-
       action_name = headers[:action].to_sym
       current_arounds = resolve_callbacks(self.class.around_actions, action_name)
 
@@ -245,12 +240,11 @@ module BugBunny
       if body.is_a?(Hash)
         params.merge!(body)
       elsif body.is_a?(String) && headers[:content_type].to_s.include?('json')
-        parsed = begin
-                   JSON.parse(body)
-                 rescue JSON::ParserError
-                   nil
-                 end
-        params.merge!(parsed) if parsed
+        begin
+          params.merge!(JSON.parse(body))
+        rescue JSON::ParserError => e
+          raise BugBunny::BadRequest, "Invalid JSON in request body: #{e.message}"
+        end
       else
         self.raw_string = body
       end
@@ -284,7 +278,8 @@ module BugBunny
     end
 
     def compute_tags
-      self.class.log_tags.map do |tag|
+      tags = self.class.log_tags.presence || BugBunny.configuration.log_tags
+      tags.map do |tag|
         case tag
         when Proc
           tag.call(self)

data/lib/bug_bunny/resource.rb

@@ -154,9 +154,24 @@ module BugBunny
       end
 
       # Proxy para el encadenamiento del método `.with`.
+      # Solo puede usarse para UNA llamada de método: el contexto se restaura al finalizar.
       class ScopeProxy < BasicObject
-        def initialize(target, keys, old_values); @target = target; @keys = keys; @old_values = old_values; end
-        def method_missing(method, *args, &block); @target.public_send(method, *args, &block); ensure; @keys.each { |k, v| ::Thread.current[v] = @old_values[k] }; end
+        def initialize(target, keys, old_values)
+          @target = target
+          @keys = keys
+          @old_values = old_values
+          @used = false
+        end
+
+        def method_missing(method, *args, &block)
+          if @used
+            ::Kernel.raise ::BugBunny::Error, "ScopeProxy is single-use. Call .with again for a new context."
+          end
+          @used = true
+          @target.public_send(method, *args, &block)
+        ensure
+          @keys.each { |k, v| ::Thread.current[v] = @old_values[k] }
+        end
       end
 
       # Calcula la routing key final.

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.0"
+  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.0
+  version: 4.1.2
 platform: ruby
 authors:
 - gabix