bug_bunny 4.7.0 → 4.8.0

data/docs/ai/faq_external.md

@@ -0,0 +1,133 @@
+## FAQ — External (Integrator / Consumer of BugBunny)
+
+### How do I set up BugBunny in a Rails app?
+
+Add to Gemfile: `gem 'bug_bunny'` and `gem 'connection_pool'`. Run `rails generate bug_bunny:install`. Edit `config/initializers/bug_bunny.rb` with your RabbitMQ credentials. Create a pool: `MY_POOL = ConnectionPool.new(size: 5) { BugBunny.create_connection }`. Assign it: `BugBunny::Resource.connection_pool = MY_POOL`. See `docs/howto/rails.md` for the complete setup.
+
+---
+
+### How do I make an RPC call (blocking request)?
+
+Use `Resource.find` / `Resource.where` / `Resource.create` — they all do RPC internally. For lower-level control: `client.request('users/1', method: :get, exchange: 'users_exchange', routing_key: 'users')`. The call blocks until the remote service replies or `rpc_timeout` expires.
+
+---
+
+### How do I publish without waiting for a reply?
+
+Use `client.publish('events', method: :post, exchange: 'events_exchange', routing_key: 'events', body: { ... })`. Fire-and-forget — does not block. No RPC timeout applies.
+
+---
+
+### What happens when `find` returns nil vs raises?
+
+`Resource.find` returns `nil` on 404 (does not raise). `Resource.where` returns `[]` on 404. Both raise `BugBunny::RequestTimeout` if the remote service does not reply within `rpc_timeout`. They raise `BugBunny::ServerError` on 5xx responses.
+
+---
+
+### How do I handle validation errors from the remote service?
+
+`resource.save` returns `false` on 422 and loads the remote errors into `resource.errors`. Check `resource.valid?` then `resource.errors.full_messages`. The remote service must render `{ errors: { field: ['message'] } }` for the errors to be auto-loaded.
+
+---
+
+### How do I use `.with` to override the exchange per call?
+
+```ruby
+# Block form (preferred — thread-safe, restores after block)
+Order.with(exchange: 'priority_exchange', routing_key: 'priority') do
+  Order.find(id)
+end
+
+# Single-call proxy
+Order.with(exchange: 'priority_exchange').find(id)
+# ScopeProxy is single-use — calling a second method raises BugBunny::Error
+```
+
+---
+
+### How do I define a Resource with typed attributes?
+
+```ruby
+class User < BugBunny::Resource
+  self.exchange = 'users_exchange'
+
+  attribute :id,    :integer
+  attribute :name,  :string
+  attribute :email, :string
+
+  validates :name, presence: true
+end
+```
+
+Typed attributes get ActiveModel coercion and dirty tracking. Attributes not declared with `attribute` are handled dynamically via `method_missing` and tracked in `@extra_attributes`.
+
+---
+
+### How do I add client-side middleware to a Resource?
+
+```ruby
+class Order < BugBunny::Resource
+  client_middleware do |stack|
+    stack.use MyRetryMiddleware
+  end
+end
+```
+
+Middlewares are inherited by subclasses and applied in registration order (first = outermost). `RaiseError` and `JsonResponse` are always added as the innermost middlewares by `Resource` — do not add them manually.
+
+---
+
+### How do I run the Consumer in a Rails app?
+
+The Consumer is a blocking loop. Run it in a separate process, not inside Puma:
+
+```ruby
+# lib/tasks/rabbit.rake
+task consumer: :environment do
+  conn = BugBunny.create_connection
+  consumer = BugBunny::Consumer.new(conn)
+  trap('TERM') { consumer.shutdown; exit }
+  trap('INT')  { consumer.shutdown; exit }
+  consumer.subscribe(
+    queue_name: 'my_queue', exchange_name: 'my_exchange', routing_key: 'my_key'
+  )
+end
+```
+
+---
+
+### How do I write a Controller?
+
+Subclass `BugBunny::Controller`. Place it in the namespace from `config.controller_namespace` (default: `BugBunny::Controllers`). Implement action methods (`index`, `show`, `create`, `update`, `destroy` or custom). Call `render(status:, json:)` to respond. The Consumer routes messages to `YourController.call(headers:, body:)`.
+
+---
+
+### How do I propagate trace context through RabbitMQ?
+
+On the consumer side, inject headers into replies:
+```ruby
+config.rpc_reply_headers = -> { { 'X-Trace-Id' => Tracer.current } }
+```
+On the producer side, hydrate context from the reply:
+```ruby
+config.on_rpc_reply = ->(headers) { Tracer.hydrate(headers['X-Trace-Id']) }
+```
+For consumer-side middleware (propagating from incoming request), use `ConsumerMiddleware`.
+
+---
+
+### How do I configure health checks for Kubernetes?
+
+Set `config.health_check_file = '/app/tmp/bug_bunny_health'`. BugBunny touches that file every `health_check_interval` seconds (default: 60) after verifying the RabbitMQ connection. Add a `livenessProbe` in your Kubernetes manifest checking for that file's existence.
+
+---
+
+### What is the default RPC timeout and how do I change it?
+
+Default: 10 seconds. Override globally: `config.rpc_timeout = 30`. Override per request: `client.request('users/1', method: :get, exchange: ..., timeout: 5)`. When exceeded, `BugBunny::RequestTimeout` is raised.
+
+---
+
+### Do I need to declare exchanges and queues manually?
+
+No. BugBunny declares them automatically when `subscribe` (consumer) or the first RPC call (producer) is made. Use `config.exchange_options` and `config.queue_options` for global defaults (e.g., `{ durable: true }`). Override per resource with `Resource.exchange_options=` or per call with `.with(exchange_options:)`.

data/docs/ai/faq_internal.md

@@ -0,0 +1,86 @@
+## FAQ — Internal (Maintainer / Developer of BugBunny)
+
+### Why is Producer cached per connection slot instead of instantiated per request?
+
+`Producer#initialize` calls `channel.basic_consume` on the `amq.rabbitmq.reply-to` pseudo-queue to listen for RPC replies. Creating a second `basic_consume` on the same channel raises an AMQP error. Therefore, one Producer per channel (= per connection slot) is mandatory. The cache is stored as `@_bug_bunny_producer` ivar on the Bunny connection object, which is safe because `ConnectionPool` guarantees each slot is used by one thread at a time.
+
+---
+
+### Why is Session cached per connection slot?
+
+Same reason as Producer — and the Session wraps the channel. Recreating a Session would create a new channel and invalidate the cached exchange/queue objects. Caching is stored as `@_bug_bunny_session` on the Bunny connection object.
+
+---
+
+### How does the Session handle thread safety for exchange/queue declarations?
+
+Session uses a double-checked locking pattern with a `Mutex` for its caches (`@exchange_cache`, `@queue_cache`). The read path (fast path) checks without locking; the write path acquires the mutex and checks again before writing. This avoids redundant AMQP declarations without making every read a mutex acquisition.
+
+---
+
+### Why does Resource have two dirty tracking mechanisms?
+
+ActiveModel::Dirty only tracks attributes declared with `attribute :name, :type`. BugBunny Resources allow dynamic attributes (unknown at class definition time) stored in `@extra_attributes`. These are tracked manually via `@dynamic_changes` (a `Set`). The `changed?` and `changed` methods merge both to produce a unified change list.
+
+---
+
+### How does the 3-level config cascade work in Resource?
+
+`resolve_config(key, instance_var)` checks in order:
+1. `Thread.current["bb_#{object_id}_#{key}"]` — set by `.with(...)`.
+2. `self.instance_variable_get(instance_var)` — class-level static config.
+3. Walk `superclass` chain up to (but not including) `BugBunny::Resource`.
+
+This means a subclass can override the parent's config, and `.with` overrides everything for the duration of its block.
+
+---
+
+### How does ConsumerMiddleware::Stack protect against concurrent registration?
+
+`Stack#use` wraps the append in a `@mutex.synchronize` block. The execution path (`call`) does not use the mutex — it reads `@middlewares` once at call time (snapshot). This is safe because Rails/Zeitwerk loads middleware registrations at boot, before any concurrent requests.
+
+---
+
+### How does routing with namespaces work internally?
+
+`namespace :admin { resources :users }` generates `Route` objects with:
+- `path_prefix: 'admin'` — prepended to the path pattern.
+- `namespace: 'Admin::Controllers'` — overrides the default namespace for `constantize`.
+
+In `process_message`, the Consumer resolves `base_namespace = route_info[:namespace] || config.controller_namespace` before calling `constantize`.
+
+---
+
+### What is the RCE prevention in the Consumer?
+
+After `constantize`, the Consumer checks `controller_class < BugBunny::Controller`. This prevents an attacker from crafting a message with a `type` header pointing to an arbitrary Ruby class (e.g., `Kernel` or `File`) and triggering its methods. Any class not inheriting from `BugBunny::Controller` gets a 403 reply and the message is rejected.
+
+---
+
+### How does `before_action` halt chain propagation?
+
+`run_before_actions` iterates before-actions and calls each. After each call, it checks `rendered_response`. If a filter called `render(...)`, `@rendered_response` is set. The method returns `false`, and `core_execution` skips the action and `after_actions`. After-actions do not run if the before-action chain was halted.
+
+---
+
+### How does `after_action` differ from `around_action`?
+
+`after_action` runs after the action method returns, but only if no `before_action` halted the chain and no exception was raised. `around_action` wraps the entire execution including before/after actions and is responsible for yielding. Use `around_action` when you need cleanup regardless of exceptions.
+
+---
+
+### How does `safe_log` prevent log failures from affecting main flow?
+
+`safe_log` wraps every logger call in `rescue StandardError`. It also filters sensitive keys by checking if the key string matches a predefined set of patterns (`password`, `pass`, `passwd`, `secret`, `token`, `api_key`, `auth`) before emitting values. Blocks are always passed to `logger.debug` to avoid string interpolation cost at non-debug levels.
+
+---
+
+### How is the Consumer health check implemented?
+
+`start_health_check` creates a `Concurrent::TimerTask` that runs every `health_check_interval` seconds. Each tick calls `channel.queue_declare(queue_name, passive: true)` — a passive declare that verifies the queue exists without creating it. On failure, it calls `session.close`, which triggers the reconnect loop in `subscribe`. The health file is touched on success.
+
+---
+
+### What triggers the reconnect loop in Consumer?
+
+Any `StandardError` raised inside the `subscribe` rescue block. The loop uses exponential backoff: `wait = [interval * 2^(attempt-1), max_interval].min`. If `max_reconnect_attempts` is set and exceeded, the error is re-raised, killing the process.

data/docs/ai/glossary.md

@@ -0,0 +1,45 @@
+## Glossary
+
+**AMQP** — Advanced Message Queuing Protocol. The binary wire protocol used by RabbitMQ. BugBunny uses Bunny as its AMQP client.
+
+**Exchange** — A RabbitMQ routing point. Publishers send messages to exchanges; exchanges route them to queues based on bindings and routing keys. BugBunny supports `direct`, `topic`, and `fanout` types.
+
+**Queue** — A buffer that holds messages until they are consumed. A queue is bound to an exchange with a routing key pattern.
+
+**Routing key** — A string label attached to a published message. The exchange uses it to decide which queues receive the message. In BugBunny, the routing key defaults to the pluralized resource name (e.g., `users`).
+
+**Binding** — The link between an exchange and a queue, specifying which routing key patterns match.
+
+**Session** — `BugBunny::Session`. A wrapper around a Bunny channel. Declares exchanges and queues, caches their AMQP objects, and handles double-checked locking for thread safety.
+
+**Producer** — `BugBunny::Producer`. Publishes messages to RabbitMQ. Implements both RPC (blocking) and fire-and-forget (non-blocking) modes. One Producer is cached per connection slot.
+
+**Consumer** — `BugBunny::Consumer`. The subscribe loop that runs in a worker process. Receives messages, routes them through middleware and the router, dispatches to a controller, and sends RPC replies.
+
+**RPC (Remote Procedure Call)** — A synchronous request-response pattern over RabbitMQ. The producer publishes with `reply_to: 'amq.rabbitmq.reply-to'` and blocks on a `Concurrent::IVar` until the consumer replies to that pseudo-queue.
+
+**Fire-and-forget** — An asynchronous publish with no reply expected. The producer does not block. Used for events, notifications, and side effects.
+
+**Direct Reply-to** — A RabbitMQ pseudo-queue (`amq.rabbitmq.reply-to`) that allows RPC replies without declaring a temporary queue. BugBunny uses this for all RPC responses.
+
+**Controller** — `BugBunny::Controller`. A class that handles an incoming routed message. Mirrors Rails ActionController: supports `before_action`, `around_action`, `after_action`, `rescue_from`, `params`, and `render`.
+
+**Resource** — `BugBunny::Resource`. An ActiveRecord-like ORM over AMQP. Wraps CRUD operations as RPC calls. Used by the publishing side to interact with a remote service.
+
+**Client** — `BugBunny::Client`. High-level API for the publisher side. Implements the Onion Middleware (Faraday-style) pattern around the Producer.
+
+**ConsumerMiddleware** — A pipeline of middleware objects that runs before each message is dispatched to a controller. Used for cross-cutting concerns: tracing, authentication, logging.
+
+**ConnectionPool** — A `connection_pool` gem pool of Bunny connections. Each slot holds one connection, one Session, and one Producer. `Resource.connection_pool` must be set before making AMQP calls.
+
+**IVar (Ivar / Concurrent::IVar)** — An immutable variable from the `concurrent-ruby` gem. Used to block the calling thread until the RPC reply arrives or the timeout expires.
+
+**health_check_file** — A file path that BugBunny touches periodically (every `health_check_interval` seconds) after verifying the RabbitMQ connection. Used as a liveness probe in Docker/Kubernetes.
+
+**rpc_reply_headers** — A `Proc` returning a `Hash` of AMQP headers injected into every RPC reply. Used to propagate trace context from consumer back to producer.
+
+**on_rpc_reply** — A `Proc` called on the producer's thread when an RPC reply arrives, with the reply's AMQP headers. Used to hydrate trace context in the calling service.
+
+**Namespace routing** — A DSL feature that prefixes a group of routes with a module namespace and a path prefix. Example: `namespace :admin` generates routes under `Admin::Controllers::*Controller` with path prefix `admin/`.
+
+**param_key** — The root key used to wrap the payload in POST/PUT requests. Defaults to the singularized resource name (e.g., `user` for `UsersResource`).

data/lib/bug_bunny/client.rb

@@ -31,6 +31,7 @@ module BugBunny
     # @raise [ArgumentError] Si no se proporciona un `pool`.
     def initialize(pool:)
       raise ArgumentError, "BugBunny::Client requiere un 'pool:'" if pool.nil?
+
       @pool = pool
       @stack = BugBunny::Middleware::Stack.new
       @delivery_mode = :rpc
@@ -96,7 +97,7 @@ module BugBunny
       req = BugBunny::Request.new(url)
 
       # 2. Syntactic Sugar: Mapeo de argumentos a atributos del Request
-      req.delivery_mode    = delivery_mode           # Default del cliente
+      req.delivery_mode    = delivery_mode # Default del cliente
       req.delivery_mode    = args[:delivery_mode]    if args[:delivery_mode]
       req.method           = args[:method]           if args[:method]
       req.body             = args[:body]             if args[:body]
@@ -109,8 +110,8 @@ module BugBunny
       req.exchange_options = args[:exchange_options] if args[:exchange_options]
       req.queue_options    = args[:queue_options]    if args[:queue_options]
 
-      req.params                                     = args[:params]   if args[:params]
-      req.headers.merge!(args[:headers])             if args[:headers]
+      req.params = args[:params] if args[:params]
+      req.headers.merge!(args[:headers]) if args[:headers]
 
       # 3. Configuración del usuario (bloque específico por request)
       yield req if block_given?

data/lib/bug_bunny/controller.rb

@@ -40,7 +40,6 @@ module BugBunny
 
     # @!endgroup
 
-
     # ==========================================
     # INFRAESTRUCTURA DE FILTROS Y LOGS (HEREDABLES)
     # ==========================================
@@ -102,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])
@@ -133,7 +132,6 @@ module BugBunny
     # Aplicamos automáticamente las etiquetas de logs a todas las acciones.
     around_action :apply_log_tags
 
-
     # ==========================================
     # INICIALIZACIÓN Y CICLO DE VIDA
     # ==========================================
@@ -170,25 +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
@@ -223,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
 
@@ -294,10 +290,10 @@ module BugBunny
 
     # --- 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

@@ -67,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

@@ -47,11 +47,11 @@ module BugBunny
                     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
@@ -89,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.