bug_bunny 4.6.1 → 4.8.0

data/lib/bug_bunny/consumer.rb

@@ -63,7 +63,8 @@ module BugBunny
     # @param queue_opts [Hash] Opciones adicionales para la cola (durable, auto_delete).
     # @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)
+    def subscribe(queue_name:, exchange_name:, routing_key:, exchange_type: 'direct', exchange_opts: {},
+                  queue_opts: {}, block: true)
       attempt = 0
 
       begin
@@ -74,14 +75,15 @@ module BugBunny
 
         # 📊 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 || {})
+                       .merge(BugBunny.configuration.exchange_options || {})
+                       .merge(exchange_opts || {})
         final_q_opts = BugBunny::Session::DEFAULT_QUEUE_OPTIONS
-                         .merge(BugBunny.configuration.queue_options || {})
-                         .merge(queue_opts || {})
+                       .merge(BugBunny.configuration.queue_options || {})
+                       .merge(queue_opts || {})
 
-        safe_log(:info, "consumer.start", queue: queue_name, queue_opts: final_q_opts)
-        safe_log(:info, "consumer.bound", exchange: exchange_name, exchange_type: exchange_type, routing_key: routing_key, exchange_opts: final_x_opts)
+        safe_log(:info, 'consumer.start', queue: queue_name, queue_opts: final_q_opts)
+        safe_log(:info, 'consumer.bound', exchange: exchange_name, exchange_type: exchange_type,
+                                          routing_key: routing_key, exchange_opts: final_x_opts)
 
         start_health_check(queue_name)
 
@@ -89,7 +91,7 @@ module BugBunny
           trace_id = properties.correlation_id
           logger = BugBunny.configuration.logger
 
-          core = -> {
+          core = lambda {
             if logger.respond_to?(:tagged)
               logger.tagged(trace_id) { process_message(delivery_info, properties, body) }
             elsif defined?(Rails) && Rails.logger.respond_to?(:tagged)
@@ -106,19 +108,35 @@ module BugBunny
         max_attempts = BugBunny.configuration.max_reconnect_attempts
 
         if max_attempts && attempt >= max_attempts
-          safe_log(:error, "consumer.reconnect_exhausted", max_attempts_count: max_attempts, **exception_metadata(e))
+          safe_log(:error, 'consumer.reconnect_exhausted', max_attempts_count: max_attempts, **exception_metadata(e))
           raise
         end
 
         wait = [
-          BugBunny.configuration.network_recovery_interval * (2 ** (attempt - 1)),
+          BugBunny.configuration.network_recovery_interval * (2**(attempt - 1)),
           BugBunny.configuration.max_reconnect_interval
         ].min
 
-        safe_log(:error, "consumer.connection_error", attempt_count: attempt, max_attempts_count: max_attempts || 'infinity', retry_in_s: wait, **exception_metadata(e))
+        safe_log(:error, 'consumer.connection_error', attempt_count: attempt,
+                                                      max_attempts_count: max_attempts || 'infinity', retry_in_s: wait, **exception_metadata(e))
         sleep wait
         retry
       end
+    ensure
+      shutdown
+    end
+
+    # Detiene el health check timer y cierra el canal de forma ordenada.
+    #
+    # Llamar explícitamente al hacer shutdown del worker (SIGTERM, at_exit, etc.).
+    # También se invoca automáticamente cuando `subscribe` termina por cualquier motivo.
+    #
+    # @return [void]
+    def shutdown
+      safe_log(:info, 'consumer.shutdown')
+      @health_timer&.shutdown
+      @health_timer = nil
+      session.close
     end
 
     private
@@ -138,7 +156,7 @@ module BugBunny
       path = properties.type || (properties.headers && properties.headers['path'])
 
       if path.nil? || path.empty?
-        safe_log(:error, "consumer.message_rejected", reason: :missing_type_header)
+        safe_log(:error, 'consumer.message_rejected', reason: :missing_type_header)
         session.channel.reject(delivery_info.delivery_tag, false)
         return
       end
@@ -147,8 +165,9 @@ module BugBunny
       headers_hash = properties.headers || {}
       http_method = (headers_hash['x-http-method'] || headers_hash['method'] || 'GET').to_s.upcase
 
-      safe_log(:info, "consumer.message_received", method: http_method, path: path, routing_key: delivery_info.routing_key)
-      safe_log(:debug, "consumer.message_received_body", body: body.truncate(200))
+      safe_log(:info, 'consumer.message_received', method: http_method, path: path,
+                                                   routing_key: delivery_info.routing_key)
+      safe_log(:debug, 'consumer.message_received_body', body: body.truncate(200))
 
       # ===================================================================
       # 3. Ruteo Declarativo
@@ -157,16 +176,14 @@ module BugBunny
 
       # Extraemos query params (ej. /nodes?status=active)
       query_params = uri.query ? Rack::Utils.parse_nested_query(uri.query) : {}
-      if defined?(ActiveSupport::HashWithIndifferentAccess)
-        query_params = query_params.with_indifferent_access
-      end
+      query_params = query_params.with_indifferent_access if defined?(ActiveSupport::HashWithIndifferentAccess)
 
       # Le preguntamos al motor de rutas global quién debe manejar esto
       route_info = BugBunny.routes.recognize(http_method, uri.path)
 
       if route_info.nil?
-        safe_log(:warn, "consumer.route_not_found", method: http_method, path: uri.path)
-        handle_fatal_error(properties, 404, "Not Found", "No route matches [#{http_method}] \"/#{uri.path}\"")
+        safe_log(:warn, 'consumer.route_not_found', method: http_method, path: uri.path)
+        handle_fatal_error(properties, 404, 'Not Found', "No route matches [#{http_method}] \"/#{uri.path}\"")
         session.channel.reject(delivery_info.delivery_tag, false)
         return
       end
@@ -177,28 +194,28 @@ module BugBunny
       # ===================================================================
       # 4. Instanciación del Controlador
       # ===================================================================
-      namespace = BugBunny.configuration.controller_namespace
+      base_namespace = route_info[:namespace] || BugBunny.configuration.controller_namespace
       controller_name = route_info[:controller].camelize
-      controller_class_name = "#{namespace}::#{controller_name}Controller"
+      controller_class_name = "#{base_namespace}::#{controller_name}Controller"
 
       begin
         controller_class = controller_class_name.constantize
       rescue NameError
-        safe_log(:warn, "consumer.controller_not_found", controller: controller_class_name)
-        handle_fatal_error(properties, 404, "Not Found", "Controller #{controller_class_name} not found")
+        safe_log(:warn, 'consumer.controller_not_found', controller: controller_class_name)
+        handle_fatal_error(properties, 404, 'Not Found', "Controller #{controller_class_name} not found")
         session.channel.reject(delivery_info.delivery_tag, false)
         return
       end
 
       # Verificación estricta de Seguridad (RCE Prevention)
       unless controller_class < BugBunny::Controller
-        safe_log(:error, "consumer.security_violation", reason: :invalid_controller, controller: controller_class)
-        handle_fatal_error(properties, 403, "Forbidden", "Invalid Controller Class")
+        safe_log(:error, 'consumer.security_violation', reason: :invalid_controller, controller: controller_class)
+        handle_fatal_error(properties, 403, 'Forbidden', 'Invalid Controller Class')
         session.channel.reject(delivery_info.delivery_tag, false)
         return
       end
 
-      safe_log(:debug, "consumer.route_matched", controller: controller_class_name, action: route_info[:action])
+      safe_log(:debug, 'consumer.route_matched', controller: controller_class_name, action: route_info[:action])
 
       request_metadata = {
         type: path,
@@ -217,22 +234,19 @@ module BugBunny
       # ===================================================================
       response_payload = controller_class.call(headers: request_metadata, body: body)
 
-      if properties.reply_to
-        reply(response_payload, properties.reply_to, properties.correlation_id)
-      end
+      reply(response_payload, properties.reply_to, properties.correlation_id) if properties.reply_to
 
       session.channel.ack(delivery_info.delivery_tag)
 
-      safe_log(:info, "consumer.message_processed",
+      safe_log(:info, 'consumer.message_processed',
                status: response_payload[:status],
                duration_s: duration_s(start_time),
                controller: controller_class_name,
                action: route_info[:action])
-
     rescue StandardError => e
-      safe_log(:error, "consumer.execution_error", duration_s: duration_s(start_time), **exception_metadata(e))
-      safe_log(:debug, "consumer.execution_error_backtrace", backtrace: e.backtrace.first(5).join(' | '))
-      handle_fatal_error(properties, 500, "Internal Server Error", e.message)
+      safe_log(:error, 'consumer.execution_error', duration_s: duration_s(start_time), **exception_metadata(e))
+      safe_log(:debug, 'consumer.execution_error_backtrace', backtrace: e.backtrace.first(5).join(' | '))
+      handle_fatal_error(properties, 500, 'Internal Server Error', e.message)
       session.channel.reject(delivery_info.delivery_tag, false)
     end
 
@@ -243,7 +257,7 @@ module BugBunny
     # @param correlation_id [String] ID para correlacionar la respuesta con la petición original.
     # @return [void]
     def reply(payload, reply_to, correlation_id)
-      safe_log(:debug, "consumer.rpc_reply", reply_to: reply_to, correlation_id: correlation_id)
+      safe_log(:debug, 'consumer.rpc_reply', reply_to: reply_to, correlation_id: correlation_id)
       extra_headers = BugBunny.configuration.rpc_reply_headers&.call || {}
       session.channel.default_exchange.publish(
         payload.to_json,
@@ -294,7 +308,7 @@ module BugBunny
         # 2. Si llegamos aquí, RabbitMQ y la cola están vivos. Avisamos al orquestador actualizando el archivo.
         touch_health_file(file_path) if file_path
       rescue StandardError => e
-        safe_log(:warn, "consumer.health_check_failed", queue: q_name, **exception_metadata(e))
+        safe_log(:warn, 'consumer.health_check_failed', queue: q_name, **exception_metadata(e))
         session.close
       end
       @health_timer.execute
@@ -309,7 +323,7 @@ module BugBunny
     def touch_health_file(file_path)
       FileUtils.touch(file_path)
     rescue StandardError => e
-      safe_log(:error, "consumer.health_check_file_error", path: file_path, **exception_metadata(e))
+      safe_log(:error, 'consumer.health_check_file_error', path: file_path, **exception_metadata(e))
     end
   end
 end

data/lib/bug_bunny/consumer_middleware.rb

@@ -42,36 +42,45 @@ module BugBunny
     end
 
     # Gestiona y ejecuta la cadena de middlewares del Consumer.
+    #
+    # Thread-safe: `use` y `empty?` están protegidos por un Mutex. `call` toma un
+    # snapshot del array bajo mutex y ejecuta la cadena fuera del lock para no
+    # serializar el procesamiento de mensajes.
     class Stack
       def initialize
         @middlewares = []
+        @mutex = Mutex.new
       end
 
-      # Registra un middleware en la cadena.
+      # Registra un middleware en la cadena. Thread-safe.
       #
       # @param middleware_class [Class] Clase que hereda de {Base}.
       # @return [self]
       def use(middleware_class)
-        @middlewares << middleware_class
+        @mutex.synchronize { @middlewares << middleware_class }
         self
       end
 
-      # @return [Boolean] `true` si no hay middlewares registrados.
+      # @return [Boolean] `true` si no hay middlewares registrados. Thread-safe.
       def empty?
-        @middlewares.empty?
+        @mutex.synchronize { @middlewares.empty? }
       end
 
       # Ejecuta la cadena de middlewares envolviendo el bloque core.
       #
+      # Toma un snapshot del array de middlewares bajo mutex y construye la cadena
+      # fuera del lock para no bloquear registros concurrentes durante la ejecución.
+      #
       # @param delivery_info [Bunny::DeliveryInfo]
       # @param properties [Bunny::MessageProperties]
       # @param body [String]
       # @yieldreturn [void] El bloque core a ejecutar al final de la cadena.
       # @return [void]
       def call(delivery_info, properties, body, &core)
+        snapshot = @mutex.synchronize { @middlewares.dup }
         terminal = ->(_di, _props, _body) { core.call }
 
-        chain = @middlewares.reverse.inject(terminal) do |next_step, middleware_class|
+        chain = snapshot.reverse.inject(terminal) do |next_step, middleware_class|
           middleware_class.new(next_step)
         end
 

data/lib/bug_bunny/controller.rb

@@ -9,7 +9,7 @@ module BugBunny
   #
   # Actúa como el receptor final de los mensajes enrutados desde el consumidor.
   # Implementa un ciclo de vida similar a ActionController en Rails, soportando:
-  # - Filtros (`before_action`, `around_action`).
+  # - Filtros (`before_action`, `around_action`, `after_action`).
   # - Manejo declarativo de errores (`rescue_from`).
   # - Parsing de parámetros unificados (`params`).
   # - Respuestas estructuradas (`render`).
@@ -40,7 +40,6 @@ module BugBunny
 
     # @!endgroup
 
-
     # ==========================================
     # INFRAESTRUCTURA DE FILTROS Y LOGS (HEREDABLES)
     # ==========================================
@@ -49,6 +48,7 @@ module BugBunny
     # hacia las subclases (ej. de ApplicationController a ServicesController).
     class_attribute :before_actions, default: {}
     class_attribute :around_actions, default: {}
+    class_attribute :after_actions,  default: {}
     class_attribute :log_tags, default: []
     class_attribute :rescue_handlers, default: []
 
@@ -72,6 +72,17 @@ module BugBunny
       register_callback(:around_actions, method_name, options)
     end
 
+    # Registra un filtro que se ejecutará **después** de la acción.
+    # No se ejecuta si un `before_action` halted la cadena (render anticipado)
+    # ni si la acción lanzó una excepción, siguiendo el comportamiento de Rails.
+    #
+    # @param method_name [Symbol] Nombre del método privado a ejecutar.
+    # @param options [Hash] Opciones como `only: [:create, :update]`.
+    # @return [void]
+    def self.after_action(method_name, **options)
+      register_callback(:after_actions, method_name, options)
+    end
+
     # Manejo declarativo de excepciones.
     # Atrapa errores específicos que ocurran durante la ejecución de la acción.
     #
@@ -90,7 +101,7 @@ module BugBunny
       raise ArgumentError, "Need a handler. Supply 'with: :method' or a block." unless handler
 
       # Duplicamos el array del padre para no mutarlo al registrar reglas en el hijo
-      new_handlers = self.rescue_handlers.dup
+      new_handlers = rescue_handlers.dup
 
       klasses.each do |klass|
         new_handlers.unshift([klass, handler])
@@ -121,14 +132,16 @@ module BugBunny
     # Aplicamos automáticamente las etiquetas de logs a todas las acciones.
     around_action :apply_log_tags
 
-
     # ==========================================
     # INICIALIZACIÓN Y CICLO DE VIDA
     # ==========================================
 
+    # @return [Hash] Headers que se enviarán en la respuesta.
+    attr_accessor :response_headers
+
     def initialize(attributes = {})
       super
-      @response_headers = {}
+      @response_headers = {}.with_indifferent_access
       @logger = BugBunny.configuration.logger
     end
 
@@ -155,23 +168,22 @@ module BugBunny
       core_execution = lambda do
         return unless run_before_actions(action_name)
 
-        if respond_to?(action_name)
-          public_send(action_name)
-        else
-          raise NameError, "Action '#{action_name}' not found in #{self.class.name}"
-        end
+        raise NameError, "Action '#{action_name}' not found in #{self.class.name}" unless respond_to?(action_name)
+
+        public_send(action_name)
+
+        run_after_actions(action_name)
       end
 
       # Construir e invocar la cadena de responsabilidad (Middlewares/Around Actions)
       execution_chain = current_arounds.reverse.inject(core_execution) do |next_step, method_name|
-        lambda { send(method_name, &next_step) }
+        -> { send(method_name, &next_step) }
       end
 
       execution_chain.call
 
       # Si no hubo renderización explícita, devuelve 204 No Content
       rendered_response || { status: 204, headers: response_headers, body: nil }
-
     rescue StandardError => e
       handle_exception(e)
     end
@@ -206,12 +218,13 @@ module BugBunny
       end
 
       # Fallback genérico si la excepción no fue mapeada
-      safe_log(:error, "controller.unhandled_exception", backtrace: exception.backtrace.first(5).join(" | "), **exception_metadata(exception))
+      safe_log(:error, 'controller.unhandled_exception', backtrace: exception.backtrace.first(5).join(' | '),
+                                                         **exception_metadata(exception))
 
       {
         status: 500,
         headers: response_headers,
-        body: { error: "Internal Server Error", detail: exception.message, type: exception.class.name }
+        body: { error: 'Internal Server Error', detail: exception.message, type: exception.class.name }
       }
     end
 
@@ -219,14 +232,15 @@ module BugBunny
     #
     # @param status [Symbol, Integer] Código HTTP (ej. :ok, :not_found, 201).
     # @param json [Object] El payload a serializar como JSON.
+    # @param headers [Hash] Headers adicionales opcionales para esta respuesta.
     # @return [Hash] La estructura renderizada interna.
-    def render(status:, json: nil)
+    def render(status:, json: nil, headers: {})
       code = Rack::Utils::SYMBOL_TO_STATUS_CODE[status] || status.to_i
       code = 200 if code.zero? # Fallback de seguridad
 
       @rendered_response = {
         status: code,
-        headers: response_headers,
+        headers: response_headers.merge(headers),
         body: json
       }
     end
@@ -267,12 +281,19 @@ module BugBunny
       true
     end
 
+    # Ejecuta secuencialmente todos los after_actions.
+    # Solo se invoca si la cadena no fue interrumpida por before_action ni por una excepción.
+    def run_after_actions(action_name)
+      current_afters = resolve_callbacks(self.class.after_actions, action_name)
+      current_afters.uniq.each { |method_name| send(method_name) }
+    end
+
     # --- LÓGICA DE LOGGING ENCAPSULADA ---
 
-    def apply_log_tags
+    def apply_log_tags(&block)
       tags = compute_tags
       if defined?(Rails) && Rails.logger.respond_to?(:tagged) && tags.any?
-        Rails.logger.tagged(*tags) { yield }
+        Rails.logger.tagged(*tags, &block)
       else
         yield
       end

data/lib/bug_bunny/exception.rb

@@ -11,6 +11,10 @@ module BugBunny
   # Suele envolver excepciones nativas de la gema `bunny` (ej: TCP connection failure).
   class CommunicationError < Error; end
 
+  # Error lanzado cuando la configuración de la gema es inválida.
+  # Se levanta al final de {BugBunny.configure} si algún atributo no pasa las validaciones.
+  class ConfigurationError < Error; end
+
   # Error lanzado cuando ocurren un acceso no permitido a controladores.
   # Protege contra vulnerabilidades de RCE validando la herencia de las clases enrutadas.
   class SecurityError < Error; end
@@ -63,7 +67,7 @@ module BugBunny
   # Indica que la solicitud fue bien formada pero contenía errores semánticos,
   # típicamente fallos de validación en el modelo remoto (ActiveRecord).
   #
-  # Esta excepción es "inteligente": intenta parsear automáticamente el cuerpo 
+  # Esta excepción es "inteligente": intenta parsear automáticamente el cuerpo
   # de la respuesta para extraer y exponer los mensajes de error de forma estructurada,
   # buscando por convención la clave `errors`.
   class UnprocessableEntity < ClientError

data/lib/bug_bunny/middleware/raise_error.rb

@@ -35,7 +35,7 @@ module BugBunny
 
         case status
         when 200..299
-          return # Flujo normal (Success)
+          nil # Flujo normal (Success)
         when 400
           raise BugBunny::BadRequest, format_error_message(body)
         when 404
@@ -66,12 +66,12 @@ module BugBunny
       # @param body [Hash, String, nil] El cuerpo de la respuesta.
       # @return [String] Un mensaje de error limpio y estructurado.
       def format_error_message(body)
-        return "Unknown Error" if body.nil? || (body.respond_to?(:empty?) && body.empty?)
+        return 'Unknown Error' if body.nil? || (body.respond_to?(:empty?) && body.empty?)
         return body if body.is_a?(String)
 
         # Si el worker devolvió un JSON con una key 'error' (nuestra convención en Controller)
         if body.is_a?(Hash) && body['error']
-          detail = body['detail'] ? " - #{body['detail']}" : ""
+          detail = body['detail'] ? " - #{body['detail']}" : ''
           "#{body['error']}#{detail}"
         else
           # Fallback: Convertir todo el Hash a JSON string para que se vea claro en Sentry/Logs

data/lib/bug_bunny/observability.rb

@@ -5,6 +5,28 @@ require 'json'
 module BugBunny
   # @api private
   module Observability
+    # Patrones de keys que deben ser ocultados en los logs.
+    # Se usa substring matching en lowercase para cubrir variantes como
+    # "user_password", "accessToken", "X-Authorization", etc.
+    # Excluye "pass" y "session" bare para evitar falsos positivos
+    # en keys como "passport_number" o "processing_session_count".
+    SENSITIVE_KEYS = %w[
+      password passwd secret token api_key auth authorization
+      credential private_key csrf session_id
+    ].freeze
+
+    # Determina si una key es sensible y debe filtrarse en los logs.
+    # Accesible como método de módulo para que otros componentes puedan reutilizarlo.
+    #
+    # @param key [String, Symbol] La clave a evaluar.
+    # @return [Boolean] `true` si la key es sensible.
+    def self.sensitive_key?(key)
+      # Normalize hyphens → underscores so HTTP headers like "X-Api-Key"
+      # match the same patterns as Ruby symbol keys like :api_key.
+      key_str = key.to_s.downcase.tr('-', '_')
+      SENSITIVE_KEYS.any? { |sensitive| key_str.include?(sensitive) }
+    end
+
     private
 
     # Registra un evento estructurado. Nunca eleva excepciones.
@@ -18,18 +40,18 @@ module BugBunny
       fields = { component: observability_name, event: event }.merge(metadata)
 
       log_line = fields.map do |k, v|
-        val = %i[password token secret api_key auth].include?(k.to_sym) ? "[FILTERED]" : v
+        val = BugBunny::Observability.sensitive_key?(k) ? '[FILTERED]' : v
         next if val.nil?
 
         formatted = case val
                     when Numeric then val
                     when Hash
                       val.to_json
-                    when String  then val.include?(" ") ? val.inspect : val
-                    else val.to_s.include?(" ") ? val.to_s.inspect : val
+                    when String then val.include?(' ') ? val.inspect : val
+                    else val.to_s.include?(' ') ? val.to_s.inspect : val
                     end
         "#{k}=#{formatted}"
-      end.compact.join(" ")
+      end.compact.join(' ')
 
       @logger.send(level) { log_line }
     rescue StandardError
@@ -67,9 +89,9 @@ module BugBunny
     # @return [String] Nombre del componente en snake_case.
     def observability_name
       klass = is_a?(Class) ? self : self.class
-      klass.name.split("::").first.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+      klass.name.split('::').first.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
     rescue StandardError
-      "unknown"
+      'unknown'
     end
   end
 end

data/lib/bug_bunny/producer.rb

@@ -79,18 +79,16 @@ module BugBunny
       begin
         fire(request)
 
-        safe_log(:debug, "producer.rpc_waiting", correlation_id: cid, timeout_s: wait_timeout)
+        safe_log(:debug, 'producer.rpc_waiting', correlation_id: cid, timeout_s: wait_timeout)
 
         # Bloqueamos el hilo aquí hasta que llegue la respuesta o expire el timeout
         result = future.value(wait_timeout)
 
-        if result.nil?
-          raise BugBunny::RequestTimeout, "Timeout waiting for RPC: #{request.path} [#{request.method}]"
-        end
+        raise BugBunny::RequestTimeout, "Timeout waiting for RPC: #{request.path} [#{request.method}]" if result.nil?
 
         BugBunny.configuration.on_rpc_reply&.call(result[:headers])
 
-        safe_log(:debug, "producer.rpc_response_received", correlation_id: cid)
+        safe_log(:debug, 'producer.rpc_response_received', correlation_id: cid)
 
         parse_response(result[:body])
       ensure
@@ -113,12 +111,12 @@ module BugBunny
 
       # 📊 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(request.exchange_options || {})
+                     .merge(BugBunny.configuration.exchange_options || {})
+                     .merge(request.exchange_options || {})
 
-      safe_log(:info, "producer.publish", method: verb, path: target, routing_key: rk, correlation_id: id)
-      safe_log(:debug, "producer.publish_detail", exchange: request.exchange, exchange_opts: final_x_opts)
-      safe_log(:debug, "producer.publish_payload", payload: payload.truncate(300)) if payload.is_a?(String)
+      safe_log(:info, 'producer.publish', method: verb, path: target, routing_key: rk, correlation_id: id)
+      safe_log(:debug, 'producer.publish_detail', exchange: request.exchange, exchange_opts: final_x_opts)
+      safe_log(:debug, 'producer.publish_payload', payload: payload.truncate(300)) if payload.is_a?(String)
     end
 
     # Serializa el mensaje para su transporte.
@@ -137,7 +135,7 @@ module BugBunny
     def parse_response(payload)
       JSON.parse(payload)
     rescue JSON::ParserError
-      raise BugBunny::InternalServerError, "Invalid JSON response"
+      raise BugBunny::InternalServerError, 'Invalid JSON response'
     end
 
     # Inicia el consumidor de respuestas RPC de forma perezosa (Lazy Initialization).
@@ -152,7 +150,7 @@ module BugBunny
       @reply_listener_mutex.synchronize do
         return if @reply_listener_started
 
-        safe_log(:debug, "producer.reply_listener_start")
+        safe_log(:debug, 'producer.reply_listener_start')
 
         # Consumimos sin ack (auto-ack) porque reply-to no soporta acks manuales de forma estándar
         @session.channel.basic_consume('amq.rabbitmq.reply-to', '', true, false, nil) do |_, props, body|
@@ -160,7 +158,7 @@ module BugBunny
           if (future = @pending_requests[cid])
             future.set({ body: body, headers: props.headers || {} })
           else
-            safe_log(:warn, "producer.rpc_response_orphaned", correlation_id: cid)
+            safe_log(:warn, 'producer.rpc_response_orphaned', correlation_id: cid)
           end
         end
         @reply_listener_started = true

data/lib/bug_bunny/railtie.rb

@@ -14,9 +14,7 @@ module BugBunny
     # 1. Configuración de Autoload
     initializer 'bug_bunny.add_autoload_paths' do |app|
       rabbit_path = File.join(app.root, 'app', 'rabbit')
-      if Dir.exist?(rabbit_path)
-        app.config.paths.add 'app/rabbit', eager_load: true
-      end
+      app.config.paths.add 'app/rabbit', eager_load: true if Dir.exist?(rabbit_path)
     end
 
     # 2. Gestión de Forks (Puma / Spring / otros)
@@ -25,9 +23,7 @@ module BugBunny
     # el hijo empiece a trabajar, para evitar compartir el mismo socket TCP.
     config.after_initialize do
       # Estrategia 1: Rails 7.1+ ForkTracker (La forma estándar moderna)
-      if defined?(ActiveSupport::ForkTracker)
-        ActiveSupport::ForkTracker.after_fork { BugBunny.disconnect }
-      end
+      ActiveSupport::ForkTracker.after_fork { BugBunny.disconnect } if defined?(ActiveSupport::ForkTracker)
 
       # Estrategia 2: Hook específico de Puma (Legacy)
       # Solo intentamos usarlo si la API 'events' está disponible (Puma < 5).
@@ -38,7 +34,12 @@ module BugBunny
       end
     end
 
-    # 3. Hook de Spring (Preloader)
+    # 3. Rake tasks (bug_bunny:sync)
+    rake_tasks do
+      load File.expand_path('../tasks/bug_bunny.rake', __dir__)
+    end
+
+    # 4. Hook de Spring (Preloader)
     if defined?(Spring)
       Spring.after_fork do
         BugBunny.disconnect

data/lib/bug_bunny/request.rb

@@ -23,20 +23,11 @@ module BugBunny
   # @attr exchange_options [Hash] Opciones específicas para la declaración del Exchange en esta petición.
   # @attr queue_options [Hash] Opciones específicas para la declaración de la Cola en esta petición.
   class Request
-    attr_accessor :body
-    attr_accessor :headers
-    attr_accessor :params
-    attr_accessor :path
-    attr_accessor :method
-    attr_accessor :exchange
-    attr_accessor :exchange_type
-    attr_accessor :routing_key
-    attr_accessor :timeout
-    attr_accessor :delivery_mode
+    attr_accessor :body, :headers, :params, :path, :method, :exchange, :exchange_type, :routing_key, :timeout,
+                  :delivery_mode, :queue_options
 
     # Configuración de Infraestructura Específica
     attr_accessor :exchange_options
-    attr_accessor :queue_options
 
     # Metadatos AMQP Estándar
     attr_accessor :app_id, :content_type, :content_encoding, :priority,
@@ -61,6 +52,7 @@ module BugBunny
       @exchange_options = {}
       @queue_options = {}
     end
+
     # Combina el path con los params como query string.
     #
     # @return [String] El path completo con query string si hay params, o solo el path.