bug_bunny 5.2.0 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ac482578cfbb87414309cc03502be5f11c4ee4b0e799338bfeb9bfcf65488f5
-  data.tar.gz: a4a9e64ac077bd6564790a5de762c804d38c65623f2c7cbc839217bb8f98bd25
+  metadata.gz: 6a28c7b99a99dc128e597b0dd3c6d128ab0abcf634410603f1dbeee78321ff33
+  data.tar.gz: 176ef53af6d5b7de0d6d10426aad13dbce548c2e894fd06db43550146791c216
 SHA512:
-  metadata.gz: e33cbdca7040793e46116fdf744d3f89bdd71a4b278a12aaa85f3845c6aba1ea86dbfded00c3108b60e04759dea07f52a7765d430fcc3bbc3ff2090b01f38c9a
-  data.tar.gz: be41989086784220c62b3e9ee4909f064956c3bf7dcaade12473d039c16743732a75f1d60844ffc22fcbe0afb36c518e14dbb74713cc0ef7007f9658d2be13d1
+  metadata.gz: ed8f25adc078770d9009b145cae463a772d0bae7234dcbae31e398f65896c7a055f230952c626becab97f235cbf23c66cd590938189ef4176c4bcecd94db092e
+  data.tar.gz: 0e5a151b21aee8a2647c41a8407df889d36582eb45026c4ca8a6a1d04b3bd0109a0e371e1a1f00d7625247e8be9ed6baf9b14c8a7ef28c9b50b5f6a0262207f2

data/.rspec

@@ -0,0 +1,2 @@
+<%# spec/rails/ bootea Rails y corre en su propio proceso: se excluye salvo que se pida explícitamente. %>
+<%= '--exclude-pattern spec/rails/**/*_spec.rb' unless ARGV.any? { |arg| arg.start_with?('spec/rails') } %>

data/AGENTS.md

@@ -12,7 +12,7 @@ proyecto y convenciones de equipo, ver `CLAUDE.md`. Para la entrada humana, ver
 
 | capa | artefacto | estado | qué responde |
 |---|---|---|---|
-| Comportamiento | `docs/behavior/behavior.md` | completo (7 flujos) | secuencias de publish/RPC/consume/confirms, contrato de error-wrapping |
+| Comportamiento | `docs/behavior/behavior.md` | completo (8 flujos) | secuencias de publish/RPC/consume/confirms, contrato de error-wrapping |
 | Glosario | `docs/glossary/glossary.md` | parcial (acreta por PR) | término de negocio → binding físico en `lib/` |
 | Errores | `docs/errors/errors.md` | completo (§a/b/d estructura + §c política inferida) | jerarquía de excepciones públicas, mapeo `status→excepción`, shape del payload, política retry |
 | Configuración | `docs/config/configuracion.md` | completo (estructura + enrich §f/g/h) | opciones de `Configuration`, defaults, failure-mode/threading, inyecciones del `Railtie`, ENV sugeridas |
@@ -38,6 +38,7 @@ a YARD/specs/CHANGELOG. Pendiente de **verificación humana** (inferencias):
 
 - Ruby: `.ruby-version` · gemas: `Gemfile.lock` · manager: chruby + Bundler.
 - Antes de commitear: `bundle exec rubocop -a` (base `rubocop-rails-omakase`),
-  `bundle exec rspec`, YARD incremental (`bundle exec yard stats --list-undoc`).
+  `bundle exec rake` (las dos suites: `spec/` y `spec/rails/`, cada una en su proceso; `bundle exec rspec` solo
+  corre `spec/`, sin Rails), YARD incremental (`bundle exec yard stats --list-undoc`).
 - Releases: `/gem-release` (el GitHub Action publica a RubyGems al pushear tag `v*`).
 - Doc por-PR: si tocás una capa, mové su artefacto en el mismo PR (régimen RFC-001).

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [5.3.0] - 2026-10-16
+
+### Nuevas funcionalidades
+- **Dentro de Rails, cada mensaje del Consumer corre dentro del executor de Rails (#70):** el railtie registra `BugBunny::ConsumerMiddleware::RailsExecutor`, que envuelve cada mensaje con `Rails.application.executor.wrap`, como Sidekiq con cada job. El Consumer procesa en el hilo de trabajo de Bunny, que Rails no conoce, así que hasta ahora lo que Rails guarda por hilo pasaba de un mensaje al siguiente: los `CurrentAttributes` (tags de Sentry, contexto de traza, métricas por ejecución) y la conexión de ActiveRecord (el hilo la retenía en vez de devolverla al pool). Fuera de Rails no se registra nada y la gema se comporta como antes. (#70, #71) — @Pslp
+- **`config.consumer_rails_executor`** (default `true`): con `false`, el railtie no registra el middleware. Se lee al terminar de inicializar la app, así que se apaga desde `config/initializers`. Si la app no llamó a `BugBunny.configure` antes de ese momento, el railtie usa la configuración por default en vez de caerse al bootear. — @Pslp
+- **`ConsumerMiddleware::Stack#prepend`:** registra un middleware al principio de la cadena. El del executor va primero así, para envolver también a los middlewares que cargan estado por hilo (el de tracing de ExisRay se registra en su propio `after_initialize`, en un orden que no controlamos). — @Pslp
+
+### ⚠️ Cambio de conducta (dentro de Rails)
+- **Rails ≥ 7.0 — un error que escapa del procesamiento de un mensaje ahora además se reporta a `Rails.error`** con `handled: false`, porque es lo que hace `executor.wrap` antes de relanzar. El camino del mensaje no cambia: se rechaza sin requeue, como desde 5.2.0. Los errores dentro de las acciones del controller los sigue rescatando el Consumer y no se ven afectados. **A mirar si consumís:** si tenés un subscriber de `Rails.error` (el de Sentry, por ejemplo), esos errores ahora aparecen ahí. Para volver a la conducta anterior: `config.consumer_rails_executor = false`. — @Pslp
+- **La caché de queries de ActiveRecord queda prendida durante cada mensaje** y se limpia al terminarlo: es lo que hace el executor (`ActiveRecord::QueryCache::ExecutorHooks`). En el hilo de Bunny estaba apagada. **A mirar si consumís:** un handler que relee la misma fila dentro de un mensaje esperando que otro proceso la cambie (un poll) ahora recibe el valor cacheado; usá `ActiveRecord::Base.uncached { … }` ahí. Se vuelve a la conducta anterior con `config.consumer_rails_executor = false`. — @Pslp
+
+### Tests
+- `spec/rails/`: una app Rails mínima (ActiveRecord sobre SQLite en memoria) prueba el railtie con Rails de verdad. Corre en su propio proceso (`rake spec:rails`), para que el resto de la suite siga probando la gema fuera de Rails; `rake` sin argumentos corre las dos, y `rspec` pelado corre `spec/` (un `.rspec` excluye `spec/rails/` salvo que se lo pida: `rspec spec/rails` la corre). Suma `railties`, `activerecord` y `sqlite3` como dependencias de desarrollo. — @Pslp
+
+### Documentación
+- README, `skill/` y los artefactos de `docs/` (configuración, comportamiento, tests, errores) describen el executor, la opción y los dos cambios de conducta; las metas que tocó #70 se re-anclaron a `67cca83`. — @Pslp
+
 ## [5.2.0] - 2026-09-29
 
 ### Nuevas funcionalidades

data/CLAUDE.md

@@ -61,7 +61,7 @@ BugBunny es una gema Ruby que implementa una capa de enrutamiento RESTful sobre
 
 ### Testing
 - Framework: RSpec
-- Correr: `bundle exec rspec`
+- Correr: `bundle exec rake` (las dos suites: `spec/` y `spec/rails/`, cada una en su proceso; `bundle exec rspec` solo corre `spec/`, sin Rails)
 - Todo código nuevo debe tener tests.
 
 ### Releases o Nuevas versiones

data/README.md

@@ -173,6 +173,10 @@ BugBunny.configure do |config|
   config.drain_idle_timeout  = 5
   config.drain_poll_interval = 0.1
 
+  # Rails only — wrap every consumed message in Rails.application.executor (default: true).
+  # See "Rails executor around each message" below. Set it from config/initializers.
+  config.consumer_rails_executor = true
+
   # Publisher Confirms — fail-loud defaults (both flags default to true).
   # Set to false to restore legacy log-only behavior.
   config.nack_raise   = true   # broker NACK → raise BugBunny::PublishNacked
@@ -362,6 +366,41 @@ end
 BugBunny.consumer_middlewares.use TracingMiddleware
 ```
 
+`use` appends to the chain; `prepend` puts a middleware first, wrapping every other one.
+
+### Rails executor around each message
+
+Inside Rails, the railtie registers `BugBunny::ConsumerMiddleware::RailsExecutor` **first** in the chain. It wraps every
+message in `Rails.application.executor.wrap`, the same way Sidekiq wraps each job. The consumer processes messages on
+Bunny's worker thread, which Rails does not know about; without the executor, what Rails keeps per thread survives from
+one message to the next:
+
+- `ActiveSupport::CurrentAttributes` (and whatever lives in them: Sentry tags, trace context, per-run metrics);
+- the ActiveRecord connection, which the thread keeps until it dies instead of returning it to the pool.
+
+It goes first (`prepend`, not `use`) so that it also wraps the middlewares that load per-thread state, like ExisRay's
+tracing middleware. Outside Rails nothing is registered and the consumer behaves as before.
+
+#### ⚠️ Behavior change
+
+**Errors that escape a message (Rails ≥ 7.0).** 
+An error that escapes the processing of a message (from a middleware, or from `handle_fatal_error`) still ends the same
+way: the delivery is rejected without requeue. **It is now also reported to `Rails.error`** with `handled: false`, because that is what `executor.wrap` does before re-raising. If you have a `Rails.error` subscriber
+(e.g. Sentry's), that error shows up there. Errors inside your controller actions are rescued by the consumer as
+before and are not affected.
+
+**The ActiveRecord query cache is on during each message**, and cleared when it ends: that is what the executor does
+(`ActiveRecord::QueryCache::ExecutorHooks`). On Bunny's thread it used to be off. A handler that re-reads the same row
+within one message, waiting for another process to change it (a poll), now gets the cached value; wrap that read in
+`ActiveRecord::Base.uncached { … }`.
+
+To turn it off (for example, if your consumer already wraps each message itself):
+
+```ruby
+# config/initializers/bug_bunny.rb
+BugBunny.configure { |config| config.consumer_rails_executor = false }
+```
+
 ---
 
 ## Observability
@@ -459,16 +498,16 @@ end
 
 Artefactos de detalle (modelo `dev-*`, RFC-001). El README indexa; no duplica.
 
-Anclado a `v5.2.0`.
+Anclado a `v5.3.0`.
 
 | Capa | Artefacto | Estado |
 |---|---|---|
 | Glosario | [docs/glossary/glossary.md](docs/glossary/glossary.md) | parcial, acreta por PR |
-| Comportamiento | [docs/behavior/behavior.md](docs/behavior/behavior.md) | completa — 6 flujos (backfill on-demand) |
+| Comportamiento | [docs/behavior/behavior.md](docs/behavior/behavior.md) | completa — 8 flujos (backfill on-demand) |
 | Configuración | [docs/config/configuracion.md](docs/config/configuracion.md) | §a-§e/§i estructura + §f/§g/§h enrich — completa |
 | Dependencias consumidas | [docs/consumed/rabbitmq.md](docs/consumed/rabbitmq.md) | §a/§b/§d estructura + §c/§e enrich |
 | Errores | [docs/errors/errors.md](docs/errors/errors.md) | §a/§b/§d completas; §c política inferida (verificación humana pendiente) |
-| Test | [docs/test/testing.md](docs/test/testing.md) | §a-§h — 16 unit / 7 integration |
+| Test | [docs/test/testing.md](docs/test/testing.md) | §a-§h — 18 unit / 8 integration / 1 rails (`spec/rails/`, en su propio proceso) |
 | Release | [docs/release/release.md](docs/release/release.md) | completa (régimen gema: build→publish; §e/f/g n/a) |
 | Datos | — | n/a — gema sin DB (sin schema/models) |
 | Eventos | — | n/a — la gema **es** el transporte; no declara catálogo de eventos de dominio propio |

data/Rakefile

@@ -4,6 +4,7 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.rspec_opts = '--require spec_helper'
+  t.exclude_pattern = 'spec/rails/**/*_spec.rb'
 end
 
 RSpec::Core::RakeTask.new('spec:unit') do |t|
@@ -16,6 +17,12 @@ RSpec::Core::RakeTask.new('spec:integration') do |t|
   t.rspec_opts = '--require spec_helper'
 end
 
+# Los specs que necesitan Rails (el Railtie) bootean una app propia, y Rails se inicializa una vez por
+# proceso: corren aparte, para que el resto de la suite siga probando la gema fuera de Rails.
+RSpec::Core::RakeTask.new('spec:rails') do |t|
+  t.pattern = 'spec/rails/**/*_spec.rb'
+end
+
 # Mantiene la tarea :test apuntando a los tests de integración legacy de Minitest
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
@@ -25,4 +32,5 @@ Rake::TestTask.new(:test) do |t|
   t.warning    = false
 end
 
-task default: :spec
+# Las dos suites, cada una en su proceso: es lo que corren `quality-code` y `gem-release`.
+task default: [:spec, 'spec:rails']

data/docs/behavior/behavior.md

@@ -1,6 +1,6 @@
 # Comportamiento — bug_bunny
 
-> meta: artefacto `comportamiento` · RFC-007 (cadencia incremental default / completo on-demand) · generado dev-enrich 1.3.0 (backfill on-demand) · anclado a `35b075a` (squash de #65 en `main`) · cobertura: completa (7 flujos) · verificado por humano 2026-05-18 (base) · 2026-05-26 (refresco scoped: contrato de error wrapping post-#49) — incremento 2026-09-28 (#64, flujo `drain` + re-mapeo de `file:line`): escrito por el agente, **sin verificación humana todavía**
+> meta: artefacto `comportamiento` · RFC-007 (cadencia incremental default / completo on-demand) · generado dev-enrich 1.3.0 (backfill on-demand) · anclado a `67cca83` (squash de #71 en `main`; antes `35b075a`) · cobertura: completa (8 flujos) · verificado por humano 2026-05-18 (base) · 2026-05-26 (refresco scoped: contrato de error wrapping post-#49) — incremento 2026-09-28 (#64, flujo `drain` + re-mapeo de `file:line`): escrito por el agente, **sin verificación humana todavía** — incremento 2026-10-16 (#70, flujo «Executor de Rails alrededor de cada mensaje»; re-anclado a `67cca83` en el release 5.3.0): escrito por el agente, **sin verificación humana todavía**
 
 ## 1. Resumen
 
@@ -17,8 +17,9 @@ Flujos de ejecución de la gema. Generado en **modo completo on-demand** (RFC-00
 | Consumer drain (drenar y salir) | **documentado** | `consumer.rb:158-176,271-290`, `drain_tracker.rb:28-47` |
 | Error handling / RemoteError | **documentado** | `consumer.rb:473-482`, `remote_error.rb`, `raise_error.rb:32-65` |
 | Client middleware stack (onion) | **documentado** | `middleware/stack.rb:43-47`, `base.rb:35-43` |
+| Executor de Rails alrededor de cada mensaje | **documentado** | `railtie.rb:44-51`, `consumer_middleware/rails_executor.rb:28-30`, `consumer.rb:227-238` |
 
-Cobertura completa a `35b075a`. Acreta incremental en cada PR que toque un flujo (default RFC-007). Ausencia futura ≠ inexistencia.
+Cobertura completa a `67cca83`. Acreta incremental en cada PR que toque un flujo (default RFC-007). Ausencia futura ≠ inexistencia.
 
 ## 2. Cuerpo
 
@@ -110,7 +111,7 @@ sequenceDiagram
     C->>H: start_health_check (touch file)
     C->>BR: q.subscribe(manual_ack, block:true) — LOOP
     loop por mensaje
-        BR->>C: deliver → consumer_middlewares → process_message
+        BR->>C: deliver → consumer_middlewares (en Rails: RailsExecutor primero) → process_message
     end
     H-->>S: cada interval: queue_declare(passive:true)
     H-->>S: falla → cierra session (fuerza reconnect)
@@ -146,6 +147,27 @@ sequenceDiagram
 ```
 Contexto: `consumer.rb:158-176` (`drain`), `consumer.rb:271-290` (`consume_until_idle`), `drain_tracker.rb:28-47`. **Mensajes que llegan mientras drena:** entran en esta vuelta si llegan antes de que venza la ventana; los posteriores quedan para la próxima corrida. Una entrega ya recibida al cancelar se procesa antes de volver (Bunny drena su work pool al cancelar — leído de la fuente de Bunny 2.24.0, no medido); si igual no se ack-eara, **vuelve a la cola** (at-least-once). El conteo devuelto incluye los rechazados. **Una entrega que falla fuera del rescue de `process_message`** (un middleware, `handle_fatal_error`) se rechaza sin requeue en `handle_delivery` y se loguea `consumer.delivery_failed`; antes quedaba sin ack, trababa el prefetch y `drain` volvía "con éxito" con la cola llena (medido en el review de #65). **Con un flujo sostenido no retorna:** si los mensajes llegan más seguido que `drain_idle_timeout` la ventana no vence — la duración la decide el productor; se acota desde afuera (timeout del job). **La conexión es del llamador:** `drain` cierra el canal, no la conexión. **Distinto de `subscribe(block: false)`:** ese modo retorna al instante y el `ensure shutdown` cierra el canal, así que no consume nada (medido en #64).
 
+### Flujo: Executor de Rails alrededor de cada mensaje
+Dentro de Rails, cada entrega corre dentro de `Rails.application.executor.wrap`, como un job de Sidekiq. El Consumer procesa en el hilo de trabajo de Bunny, que Rails no conoce: sin esto, el estado por hilo pasa de un mensaje al siguiente (#70).
+
+```mermaid
+sequenceDiagram
+    participant BR as RabbitMQ
+    participant C as Consumer#handle_delivery
+    participant X as RailsExecutor
+    participant M as otros middlewares (p. ej. tracing de ExisRay)
+    participant P as process_message
+    BR->>C: deliver (hilo de Bunny)
+    C->>X: consumer_middlewares.call
+    X->>X: executor.wrap — al entrar: reset de CurrentAttributes · prende la caché de queries de AR
+    X->>M: @app.call
+    M->>P: core: rutea, llama al controller, ack/reject, reply RPC
+    P-->>X: vuelve
+    X->>X: al salir: reset de CurrentAttributes · la conexión de AR vuelve al pool · se apaga y limpia la caché de queries
+    Note over C: un error que escapa: wrap lo relanza (en Rails ≥ 7.0, antes lo reporta a Rails.error) → rescue de handle_delivery → reject sin requeue
+```
+Contexto: `railtie.rb:44-51` (registro en `after_initialize`, sólo si `config.consumer_rails_executor`), `consumer_middleware.rb:72-75` (`Stack#prepend`), `consumer_middleware/rails_executor.rb:28-30` (`wrap`), `consumer.rb:227-238` (`handle_delivery`: la cadena y su `rescue`). **Va primero** (`prepend`) porque el reset al entrar borraría el estado que un middleware anterior ya cargó: el de tracing de ExisRay carga `ExisRay::Tracer` (un `CurrentAttributes`) y se registra en su propio `after_initialize`, en un orden que no controlamos. El ack/reject queda adentro del wrap (vive en `process_message`); el `rescue` de `handle_delivery`, afuera. Si el hilo ya está dentro del executor, `wrap` no abre otro. **Fuera de Rails** el Railtie no se carga y la cadena no cambia. Probado con Rails de verdad en `spec/rails/consumer_rails_executor_spec.rb` (Rails 8.1.4, la versión que corre la suite). **Cambio de conducta:** la caché de queries, que en el hilo de Bunny estaba apagada, queda prendida durante cada mensaje (`ActiveRecord::QueryCache::ExecutorHooks`).
+
 ### Flujo: Error handling / RemoteError
 Excepción no manejada en controller → serializada (clase/mensaje/backtrace[0..25]) → reply 500 → reconstruida client-side por `Middleware::RaiseError`.
 

data/docs/config/configuracion.md

@@ -1,7 +1,7 @@
 # Configuración — bug_bunny
 
 > meta: artefacto configuración · RFC-012 · generado `arch-structure` (inventario
-> §a-§e/§i) + `arch-enrich` (§f/§g/§h/§j) · anclado a `35b075a` (squash de #65 en `main`),
+> §a-§e/§i) + `arch-enrich` (§f/§g/§h/§j) · anclado a `67cca83` (squash de #71 en `main`),
 > `lib/bug_bunny/configuration.rb`, `lib/bug_bunny.rb`, `lib/bug_bunny/railtie.rb`,
 > `lib/bug_bunny/consumer.rb`,
 > `lib/generators/bug_bunny/install/templates/initializer.rb` · fecha 2026-06-30
@@ -9,6 +9,11 @@
 > §j n/a. Incremento 2026-09-28 (#64): `drain_idle_timeout`/`drain_poll_interval`,
 > anclados a `configuration.rb:37-38,99-105,273-275` y `consumer.rb:271-290`; todas las
 > citas `file:line` re-mapeadas al árbol de `35b075a` (el refactor de #64 las corrió).
+> Incremento 2026-10-16 (#70): `consumer_rails_executor` (`configuration.rb:196,277`,
+> `railtie.rb:44-51`); las citas de `configuration.rb` re-mapeadas por contenido (el atributo
+> nuevo corrió +10/+11 todo lo que viene después) y las de `railtie.rb` (§i). Re-anclado a
+> `67cca83` en el release 5.3.0: entre `35b075a` y `67cca83` sólo cambiaron los archivos de #70
+> (re-mapeados) y `version.rb` (no citado). Escrito por el agente, sin verificación humana todavía.
 
 ## 1. Resumen
 
@@ -22,12 +27,12 @@ en `lib/`**; el `ENV.fetch` vive en el **template** que sugiere al consumidor
 
 ### a. Hecho verificable
 
-- **Total opciones (`Configuration`):** 32 (31 `attr_accessor` + 1 `attr_reader`; medido
-  2026-09-28 — el `29` anterior ya estaba desfasado del código antes de #64).
+- **Total opciones (`Configuration`):** 33 (32 `attr_accessor` + 1 `attr_reader`; medido
+  2026-10-16, con `consumer_rails_executor` de #70 — el `29` anterior ya estaba desfasado del código antes de #64).
 - **Validadas requeridas (`VALIDATIONS`, `configuration.rb:25-39`):** 5 (`host`,
   `port`, `username`, `password`, `vhost` — `required: true`; igual tienen
   default, `validate!` exige no-vacío).
-- **Con default:** 32 (todas; defaults en `initialize`/`init_callback_defaults`/`init_drain_defaults`).
+- **Con default:** 33 (todas; defaults en `initialize`/`init_callback_defaults`/`init_drain_defaults`).
 - **Con rango validado:** 9 (`port`, `heartbeat`, `connection_timeout`,
   `read_timeout`, `write_timeout`, `rpc_timeout`, `channel_prefetch`,
   `drain_idle_timeout`, `drain_poll_interval`).
@@ -41,38 +46,39 @@ Origen `code-default` salvo nota. Consumidor = `configuration.rb` (default en
 
 | nombre | tipo | requerida | default | origen | consumidor | secret? |
 |---|---|---|---|---|---|---|
-| `host` | String | sí (validate!) | `'127.0.0.1'` | code-default | `configuration.rb:192` | no |
-| `port` | Integer | sí (validate!, 1..65535) | `5672` | code-default | `:193` | no |
-| `username` | String | sí (validate!) | `'guest'` | code-default | `:194` | no |
-| `password` | String | sí (validate!) | `'guest'` | code-default | `:195` | **sí** |
-| `vhost` | String | sí (validate!) | `'/'` | code-default | `:196` | no |
-| `logger` | Logger | no | `Logger.new($stdout)` INFO | code-default | `:198` | no |
-| `bunny_logger` | Logger | no | `Logger.new($stdout)` WARN | code-default | `:201` | no |
-| `automatically_recover` | Boolean | no | `true` | code-default | `:203` | no |
-| `network_recovery_interval` | Integer | no | `5` | code-default | `:204` | no |
-| `max_reconnect_attempts` | Integer/nil | no | `nil` (reintenta ∞) | code-default | `:205` | no |
-| `max_reconnect_interval` | Integer | no | `60` | code-default | `:206` | no |
-| `connection_timeout` | Integer | no (1..300) | `10` | code-default | `:207` | no |
-| `read_timeout` | Integer | no (1..300) | `30` | code-default | `:208` | no |
-| `write_timeout` | Integer | no (1..300) | `30` | code-default | `:209` | no |
-| `heartbeat` | Integer | no (0..3600) | `15` | code-default | `:210` | no |
-| `continuation_timeout` | Integer (ms) | no | `15000` | code-default | `:211` | no |
-| `channel_prefetch` | Integer | no (1..10000) | `1` | code-default | `:212` | no |
-| `rpc_timeout` | Integer | no (1..3600) | `10` | code-default | `:213` | no |
-| `health_check_interval` | Integer | no | `60` | code-default | `:214` | no |
-| `health_check_file` | String/nil | no | `nil` (desactivado) | code-default | `:217` | no |
-| `drain_idle_timeout` | Integer (s) | no (1..3600) | `5` | code-default | `:274` | no |
-| `drain_poll_interval` | Numeric (s) | no (0.01..10) | `0.1` | code-default | `:275` | no |
-| `controller_namespace` | String | no | `'BugBunny::Controllers'` | code-default | `:220` | no |
-| `log_tags` | Array | no | `[:uuid]` | code-default | `:222` | no |
-| `exchange_options` | Hash | no | `{}` | code-default | `:225` | no |
-| `queue_options` | Hash | no | `{}` | code-default | `:226` | no |
-| `consumer_middlewares` | Stack (attr_reader) | no | `Stack.new` | code-default | `:228` | no |
-| `rpc_reply_headers` | Proc/nil | no | `nil` | code-default | `:262` | no |
-| `on_rpc_reply` | Proc/nil | no | `nil` | code-default | `:263` | no |
-| `on_return` | Proc/nil | no | `nil` | code-default | `:264` | no |
-| `nack_raise` | Boolean | no | `true` | code-default | `:265` | no |
-| `return_raise` | Boolean | no | `true` | code-default | `:266` | no |
+| `host` | String | sí (validate!) | `'127.0.0.1'` | code-default | `configuration.rb:202` | no |
+| `port` | Integer | sí (validate!, 1..65535) | `5672` | code-default | `:203` | no |
+| `username` | String | sí (validate!) | `'guest'` | code-default | `:204` | no |
+| `password` | String | sí (validate!) | `'guest'` | code-default | `:205` | **sí** |
+| `vhost` | String | sí (validate!) | `'/'` | code-default | `:206` | no |
+| `logger` | Logger | no | `Logger.new($stdout)` INFO | code-default | `:208` | no |
+| `bunny_logger` | Logger | no | `Logger.new($stdout)` WARN | code-default | `:211` | no |
+| `automatically_recover` | Boolean | no | `true` | code-default | `:213` | no |
+| `network_recovery_interval` | Integer | no | `5` | code-default | `:214` | no |
+| `max_reconnect_attempts` | Integer/nil | no | `nil` (reintenta ∞) | code-default | `:215` | no |
+| `max_reconnect_interval` | Integer | no | `60` | code-default | `:216` | no |
+| `connection_timeout` | Integer | no (1..300) | `10` | code-default | `:217` | no |
+| `read_timeout` | Integer | no (1..300) | `30` | code-default | `:218` | no |
+| `write_timeout` | Integer | no (1..300) | `30` | code-default | `:219` | no |
+| `heartbeat` | Integer | no (0..3600) | `15` | code-default | `:220` | no |
+| `continuation_timeout` | Integer (ms) | no | `15000` | code-default | `:221` | no |
+| `channel_prefetch` | Integer | no (1..10000) | `1` | code-default | `:222` | no |
+| `rpc_timeout` | Integer | no (1..3600) | `10` | code-default | `:223` | no |
+| `health_check_interval` | Integer | no | `60` | code-default | `:224` | no |
+| `health_check_file` | String/nil | no | `nil` (desactivado) | code-default | `:227` | no |
+| `drain_idle_timeout` | Integer (s) | no (1..3600) | `5` | code-default | `:285` | no |
+| `drain_poll_interval` | Numeric (s) | no (0.01..10) | `0.1` | code-default | `:286` | no |
+| `controller_namespace` | String | no | `'BugBunny::Controllers'` | code-default | `:230` | no |
+| `log_tags` | Array | no | `[:uuid]` | code-default | `:232` | no |
+| `exchange_options` | Hash | no | `{}` | code-default | `:235` | no |
+| `queue_options` | Hash | no | `{}` | code-default | `:236` | no |
+| `consumer_middlewares` | Stack (attr_reader) | no | `Stack.new` | code-default | `:238` | no |
+| `rpc_reply_headers` | Proc/nil | no | `nil` | code-default | `:272` | no |
+| `on_rpc_reply` | Proc/nil | no | `nil` | code-default | `:273` | no |
+| `on_return` | Proc/nil | no | `nil` | code-default | `:274` | no |
+| `nack_raise` | Boolean | no | `true` | code-default | `:275` | no |
+| `return_raise` | Boolean | no | `true` | code-default | `:276` | no |
+| `consumer_rails_executor` | Boolean | no | `true` | code-default | `:277` | no |
 
 > **Override por request:** `nack_raise` y `return_raise` se sobreescriben por
 > llamada con `nack_raise:` / `return_raise:` en `Client#publish` (scope-override
@@ -93,7 +99,7 @@ El install template (`initializer.rb`) **sugiere al consumidor** wirear 4 ENV
 ### d. Derivaciones simples
 
 - `url` ← `"amqp://#{username}:#{password}@#{host}:#{port}/#{vhost}"`
-  (`configuration.rb:236`).
+  (`configuration.rb:246`).
 - `create_connection(**options)` ← `merge_connection_options(options)` sobre la
   config global; las options explícitas pisan los defaults (`bug_bunny.rb:88`).
 
@@ -106,11 +112,12 @@ El install template (`initializer.rb`) **sugiere al consumidor** wirear 4 ENV
 
 | inyección | qué hace | ancla |
 |---|---|---|
-| `initializer 'bug_bunny.add_autoload_paths'` | registra `app/rabbit` en el autoloader (Zeitwerk, `eager_load: true`) si existe | `:15-18` |
-| `config.after_initialize` → `ForkTracker.after_fork` | cierra la conexión heredada en cada fork (Rails 7.1+) | `:24-26` |
-| `config.after_initialize` → `Puma.events.on_worker_boot` | mismo cierre, hook legacy Puma <5 | `:30-34` |
-| `rake_tasks` | carga `tasks/bug_bunny.rake` (`bug_bunny:sync`) | `:38-40` |
-| `Spring.after_fork` | cierra conexión en preloader Spring | `:43-47` |
+| `initializer 'bug_bunny.add_autoload_paths'` | registra `app/rabbit` en el autoloader (Zeitwerk, `eager_load: true`) si existe | `:16-19` |
+| `config.after_initialize` → `ForkTracker.after_fork` | cierra la conexión heredada en cada fork (Rails 7.1+) | `:25-27` |
+| `config.after_initialize` → `Puma.events.on_worker_boot` | mismo cierre, hook legacy Puma <5 | `:31-35` |
+| `config.after_initialize` → `consumer_middlewares.prepend(RailsExecutor)` | si `consumer_rails_executor` (default `true`), pone `ConsumerMiddleware::RailsExecutor` **primero** en la cadena del Consumer: cada mensaje corre dentro de `Rails.application.executor.wrap` (#70) | `:44-51` |
+| `rake_tasks` | carga `tasks/bug_bunny.rake` (`bug_bunny:sync`) | `:54-56` |
+| `Spring.after_fork` | cierra conexión en preloader Spring | `:59-63` |
 
 ### f. Enriquecimiento semántico
 
@@ -128,6 +135,7 @@ del código.
 | Drain (`drain_idle_timeout`/`drain_poll_interval`) | latencia | `drain_idle_timeout` muy bajo → un productor lento deja mensajes para la próxima corrida (no se pierden); muy alto → el job tarda más en terminar tras vaciar la cola | ninguno: sólo acota cuánto espera `Consumer#drain` (`consumer.rb:285`) | correr un consumidor como job que termina (#64) |
 | Callbacks (`on_return`/`on_rpc_reply`/`rpc_reply_headers`) | extensibilidad | una excepción en `on_return` se captura pero **degrada visibilidad** (YARD `configuration.rb:157`) | corren en hilos sensibles (ver §h) | propagar trace-context / alertar unroutable |
 | Confirms (`nack_raise`/`return_raise`) | integridad de entrega | `false` → NACK/return solo se logea, la llamada retorna `202` (modo legacy, posible pérdida silenciosa) | habilitan el raise de `PublishNacked`/`PublishUnroutable` | elegir entre fail-fast vs best-effort en publish confirmado |
+| Executor de Rails (`consumer_rails_executor`) | aislamiento entre mensajes | `false` dentro de Rails → el estado por hilo (`CurrentAttributes`, conexión de ActiveRecord) pasa de un mensaje al siguiente, salvo que el consumidor envuelva cada mensaje por su cuenta; fuera de Rails no tiene efecto | `true` → el Railtie registra `ConsumerMiddleware::RailsExecutor` **primero** en la cadena (`railtie.rb:44-51`); en Rails ≥ 7.0, un error que escapa del mensaje además se reporta a `Rails.error` (`handled: false`), y la caché de queries de AR queda prendida durante cada mensaje | que cada mensaje empiece limpio, como un job de Sidekiq (#70) |
 | Routing (`controller_namespace`) | seguridad | clase resuelta no subclase de `BugBunny::Controller` → el worker responde **403** + reject (guard anti-RCE, `consumer.rb:375-381`) | acota qué clases son enrutables | superficie de control de RCE |
 | Logging (`logger`/`bunny_logger`/`log_tags`) | observabilidad | — | salida a `$stdout` por default | trazabilidad estructurada |
 | Infra (`exchange_options`/`queue_options`) | infraestructura | options incompatibles con el broker → `PreconditionFailed` (vía `CommunicationError`) | defaults globales mergeados por recurso | declaración AMQP por default |
@@ -135,7 +143,7 @@ del código.
 ### g. Ramificadores intra-config
 
 - `health_check_file = nil` (default) **desactiva** el touchfile aunque
-  `health_check_interval` siga corriendo (`configuration.rb:109-111,217`).
+  `health_check_interval` siga corriendo (`configuration.rb:109-111,227`).
 - `return_raise` es **inerte cuando `mandatory: false`** — sin `mandatory` el
   broker nunca retorna, así que el flag no tiene efecto (`configuration.rb:181`).
 - `nack_raise`/`return_raise` se sobreescriben **por request** (`Client#publish`),

data/docs/errors/errors.md

@@ -5,7 +5,9 @@
 > `remote_error.rb`, `middleware/raise_error.rb`, `controller.rb`, `consumer.rb`,
 > `observability.rb` · fecha 2026-07-31 · cobertura: §a/§b/§d completas
 > (estructura); §c política completa (enrich, **inferida** de HTTP/AMQP —
-> verificación humana pendiente).
+> verificación humana pendiente). Incremento 2026-10-16 (#70): las citas de `configuration.rb`
+> (`:293,300,308`, los `raise` de `ConfigurationError`) son del árbol de `67cca83`; el resto sigue
+> anclado a `5697541`.
 
 ## 1. Resumen
 
@@ -46,7 +48,7 @@ Jerarquía (todas bajo `BugBunny::Error < ::StandardError`):
 |---|---|---|
 | `Error` | `::StandardError` | base — no se levanta directa salvo `resource.rb:122` (pool ausente) |
 | `CommunicationError` | `Error` | `bug_bunny.rb:96`, `session.rb:177,285`, `producer.rb:90`, `client.rb:168` — envuelve cualquier `Bunny::Exception` en la frontera del gem; original en `.cause` |
-| `ConfigurationError` | `Error` | `configuration.rb:282,289,297` — validación al final de `BugBunny.configure` |
+| `ConfigurationError` | `Error` | `configuration.rb:293,300,308` — validación al final de `BugBunny.configure` |
 | `PublishNacked` | `Error` | `producer.rb:235` — NACK del broker en modo `:confirmed`. Attrs: `path`, `nacked_count`. Opt-out `nack_raise: false` |
 | `PublishUnroutable` | `Error` | `producer.rb:325` — `basic.return` con `mandatory: true`. Attrs: `path`, `exchange`, `routing_key`, `reply_code`, `reply_text`, `correlation_id`. Opt-out `return_raise: false` |
 | `ClientError` | `Error` | `raise_error.rb:170` — 4xx no mapeado explícito |

data/docs/release/release.md

@@ -5,7 +5,9 @@
 > a la RFC vigente) · anclado a `5697541`
 > (`.github/workflows/release.yml`, `*.gemspec`, `lib/bug_bunny/version.rb`,
 > `CHANGELOG.md`) · fecha 2026-07-31 · cobertura:
-> completa (régimen gema: build→publish, §e/f/g n/a).
+> completa (régimen gema: build→publish, §e/f/g n/a). Incremento 2026-10-16 (release 5.3.0):
+> versión actual y los pines de los consumidores (§h), re-medidos; escrito por el agente, sin
+> verificación humana todavía.
 
 ## 1. Resumen
 
@@ -21,9 +23,9 @@ out-of-repo).
 
 ### a. Hecho verificable
 
-- **Convención de versión:** SemVer `vX.X.X`. Actual: **5.2.0**.
-- **Source of truth:** tag remoto (`v5.2.0`) + **triple mirror**
-  `lib/bug_bunny/version.rb` (`VERSION = '5.2.0'`) ← `bug_bunny.gemspec:7`
+- **Convención de versión:** SemVer `vX.X.X`. Actual: **5.3.0**.
+- **Source of truth:** tag remoto (`v5.3.0`) + **triple mirror**
+  `lib/bug_bunny/version.rb` (`VERSION = '5.3.0'`) ← `bug_bunny.gemspec:7`
   (`spec.version = BugBunny::VERSION`).
 - **Changelog canónico:** `CHANGELOG.md` único.
 - **Patrón de trigger:** `gema-tag` (patrón 1).
@@ -34,7 +36,7 @@ out-of-repo).
 
 - **Convención:** SemVer `vX.X.X` (**con `v`** — distinto al servicio).
 - **Source of truth:** tag remoto canónico (`git tag --sort=-v:refname` →
-  `v5.2.0`).
+  `v5.3.0`).
 - **Mirror:** `lib/bug_bunny/version.rb` (`VERSION`), leído por
   `bug_bunny.gemspec:7` (`spec.version = BugBunny::VERSION`).
   `required_ruby_version >= 2.6.0` (`bug_bunny.gemspec:17`).
@@ -85,11 +87,12 @@ procedimiento per-repo porque no vive acá. Una versión yankeada se anotaría e
   `>= 5.1.0, < 5.2.0`, así que un minor **no entra** sin editar el `Gemfile`.
   Consecuencia operativa: un fix publicado como **patch** lo toman con
   `bundle update bug_bunny`; uno publicado como **minor** requiere tocar el pin
-  en cada consumidor. Estado medido el 2026-09-29 (Gemfiles de los clones del
+  en cada consumidor. Estado medido el 2026-10-16 (Gemfile y Gemfile.lock del default de cada clon del
   workspace): `box_manager_service` en `~> 5.1.1`; `box_acs_manager`,
-  `box_cluster_manager` y `box_radius_manager` en `~> 5.1.0` — o sea que
-  **5.2.0 no le entra a ninguno** sin tocar el pin. *(El estado anterior decía
-  `box_acs_manager`/`box_cluster_manager` en `~> 4.19.0`: ya no es así.)* Un cambio de contrato del gem (ej. el
+  `box_cluster_manager` y `box_radius_manager` en `~> 5.1.0`, los cuatro con 5.1.1 en el lock — o sea que
+  **ni 5.2.0 ni 5.3.0 le entran a ninguno** sin tocar el pin. `agent` sigue en `~> 4.11.1`, y el resto de
+  los consumidores (`olt_*`, `*_invoice_service`, `notification_sms_service`, `wispro_box_server`,
+  `wispro_lan`) en la línea 0.2.x. *(El 2026-09-29 la medición daba lo mismo para los cuatro de 5.x.)* Un cambio de contrato del gem (ej. el
   behavior-change de `4.18.0` — `Bunny::Exception` → `CommunicationError`, o la
   eliminación de `BugBunny::SecurityError` en `5.0.0`) obliga a los consumidores
   a migrar; el `CHANGELOG.md` lo documenta como breaking note. **Orden de

data/docs/test/testing.md

@@ -1,17 +1,22 @@
 # Test — bug_bunny
 
 > meta: artefacto test · RFC-013 · generado `arch-structure` (§a-§d) +
-> `arch-enrich` (§e-§h) · anclado a `35b075a` (squash de #65 en `main`; el ancla anterior `7bf1da7` no era ancestro de `main`), `Rakefile`, `bug_bunny.gemspec`,
+> `arch-enrich` (§e-§h) · anclado a `67cca83` (squash de #71 en `main`; antes `35b075a`, y antes `7bf1da7`, que no era ancestro de `main`), `Rakefile`, `bug_bunny.gemspec`,
 > `spec/spec_helper.rb`, `spec/support/integration_helper.rb`,
 > `.github/workflows/main.yml`, `CHANGELOG.md` · fecha 2026-07-22 · cobertura:
 > §a-§d (estructura) + §e-§h (enrich, anclado a specs/CHANGELOG) completas.
 > Incremento 2026-09-28 (#64): conteos, `drain_*_spec` y el gap de aislamiento.
+> Incremento 2026-10-16 (#70): `spec/rails/` (Railtie con Rails de verdad), tarea
+> `spec:rails` y conteos; re-anclado a `67cca83` en el release 5.3.0. Escrito por el agente, sin
+> verificación humana todavía.
 
 ## 1. Resumen
 
-Suite principal **RSpec** (`spec/`, 25 specs: 17 unit + 8 integration). Tarea
+Suite principal **RSpec** (`spec/`, 27 specs: 18 unit + 8 integration + 1 rails). Tarea
 `:test` legacy de **Minitest** (`test/`, 2 archivos) fuera del default y del CI.
-CI corre `bundle exec rake` (= `:spec`) en Ruby 3.4.4. Sin coverage tool
+CI corre `bundle exec rake` en Ruby 3.4.4: el default corre `:spec` y `spec:rails`, cada una en
+su proceso. `bundle exec rspec` pelado corre `spec/` sin Rails: `.rspec` excluye `spec/rails/` salvo que se lo pida
+explícitamente (`bundle exec rspec spec/rails` la corre, en su propio proceso). Sin coverage tool
 configurado.
 
 ## 2. Cuerpo
@@ -20,7 +25,8 @@ configurado.
 
 | framework | dir | nivel | nº | propósito |
 |---|---|---|---|---|
-| **RSpec** `~> 3.0` | `spec/unit/` | unit | 17 | client/session pool, configuration, consumer, `drain_tracker`, producer, controller, raise_error, remote_error, request, route, observability, otel, resource, middleware, `extra_top_level_params` (hook de params hermanos en `Resource#save`) |
+| **RSpec** `~> 3.0` | `spec/unit/` | unit | 18 | client/session pool, configuration, consumer, `drain_tracker`, producer, controller, raise_error, remote_error, request, route, observability, otel, resource, middleware, `extra_top_level_params` (hook de params hermanos en `Resource#save`), `consumer_rails_executor_outside_rails` (fuera de Rails no se carga el Railtie ni el middleware del executor) |
+| **RSpec** + `railties`/`activerecord`/`sqlite3` | `spec/rails/` | integration con Rails (sin broker) | 1 | `consumer_rails_executor`: una app Rails mínima (`spec/rails/app.rb`, ActiveRecord sobre SQLite en memoria) prueba que cada mensaje corre dentro del executor — el `CurrentAttributes` no pasa al siguiente, la conexión vuelve al pool, el orden frente a un middleware de tracing, el error que escapa (reject + `Rails.error`) y `consumer_rails_executor = false` (en subproceso) |
 | **RSpec** | `spec/integration/` | integration | 8 | client, consumer_middleware, controller, drain, error_handling, infrastructure, publisher_confirms, resource — **requieren RabbitMQ real** (usan `BugBunny.create_connection` + pool) |
 | **Minitest** `~> 5.0` (+ `mocha`, `minitest-reporters`) | `test/integration/` | integration (legacy) | 2 | `manual_client_test.rb`, `infrastructure_test.rb` — tarea `:test`, **no** en default ni CI |
 
@@ -30,13 +36,16 @@ Sin tags declarados (`:slow`/`:js`) en la config de RSpec.
 
 | objetivo | comando | qué corre |
 |---|---|---|
-| default / CI | `bundle exec rake` | tarea `:spec` (toda la suite RSpec) — `Rakefile:` `task default: :spec` |
+| default / CI | `bundle exec rake` | `:spec` (la suite RSpec menos `spec/rails/`) y después `spec:rails`, cada una en su proceso — `Rakefile:` `task default: [:spec, 'spec:rails']` |
+| `spec/` sin Rails | `bundle exec rspec` | todo `spec/` menos `spec/rails/` (lo excluye `.rspec` cuando no se pide `spec/rails` explícitamente) |
 | solo unit | `bundle exec rake spec:unit` | `spec/unit/**/*_spec.rb` |
 | solo integration | `bundle exec rake spec:integration` | `spec/integration/**/*_spec.rb` (requiere broker) |
+| Railtie (Rails) | `bundle exec rake spec:rails` | `spec/rails/**/*_spec.rb`, en su propio proceso (Rails se inicializa una vez por proceso); equivale a `bundle exec rspec spec/rails` |
 | Minitest legacy | `bundle exec rake test` | `test/**/*_test.rb` |
 | CI | `.github/workflows/main.yml` → `bundle exec rake` | matrix Ruby `3.4.4`, `ruby/setup-ruby@v1` + `bundler-cache`, on push `main` + PR |
 
-> Todas las tareas RSpec corren con `--require spec_helper` (`Rakefile`).
+> Las tareas RSpec corren con `--require spec_helper` (`Rakefile`), salvo `spec:rails`, que
+> carga su propio `spec/rails/rails_helper.rb`.
 
 ### c. Fixtures / Factories
 

data/lib/bug_bunny/configuration.rb

@@ -185,6 +185,16 @@ module BugBunny
     #   `Client#publish`.
     attr_accessor :return_raise
 
+    # @return [Boolean] Si `true` (default) y la gema corre dentro de Rails, el Railtie envuelve
+    #   cada mensaje del Consumer con `Rails.application.executor.wrap`
+    #   ({BugBunny::ConsumerMiddleware::RailsExecutor}): el estado por hilo (`CurrentAttributes`,
+    #   la conexión de ActiveRecord) no pasa de un mensaje al siguiente.
+    #   Fuera de Rails no tiene efecto.
+    #
+    #   Se lee al terminar de inicializar la app, así que se apaga desde `config/initializers`.
+    #   Apagalo si el consumidor ya envuelve cada mensaje por su cuenta.
+    attr_accessor :consumer_rails_executor
+
     # @!endgroup
 
     # Inicializa la configuración con valores por defecto seguros.
@@ -264,6 +274,7 @@ module BugBunny
       @on_return = nil
       @nack_raise = true
       @return_raise = true
+      @consumer_rails_executor = true
     end
 
     # Defaults de {BugBunny::Consumer#drain}.

data/lib/bug_bunny/consumer_middleware/rails_executor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module BugBunny
+  module ConsumerMiddleware
+    # Envuelve cada mensaje con el executor de Rails, como hace Sidekiq con cada job.
+    #
+    # El Consumer procesa los mensajes en el hilo de trabajo de Bunny, que Rails no conoce. Sin
+    # el executor, lo que Rails guarda por hilo pasa de un mensaje al siguiente:
+    # - los `ActiveSupport::CurrentAttributes` (y lo que vive en ellos: tags, trazas, métricas);
+    # - la conexión de ActiveRecord, que el hilo retiene hasta morir en vez de devolverla al pool.
+    #
+    # Además, el executor prende la caché de queries de ActiveRecord durante el mensaje y la limpia al
+    # terminarlo (en el hilo de Bunny estaba apagada).
+    #
+    # Lo registra el Railtie al principio de la cadena (ver {Stack#prepend}) salvo que
+    # `config.consumer_rails_executor` sea `false`. Fuera de Rails no se carga.
+    #
+    # **Errores:** `executor.wrap` relanza lo que escapa del mensaje, así que sigue el camino de
+    # siempre (el Consumer lo rechaza sin requeue). En Rails >= 7.0, antes de relanzar, además lo
+    # reporta a `Rails.error` con `handled: false`.
+    #
+    # Si el hilo ya está dentro del executor, `wrap` no abre otro: sólo ejecuta el bloque.
+    class RailsExecutor < Base
+      # @param delivery_info [Bunny::DeliveryInfo]
+      # @param properties [Bunny::MessageProperties]
+      # @param body [String]
+      # @return [void]
+      def call(delivery_info, properties, body)
+        ::Rails.application.executor.wrap { @app.call(delivery_info, properties, body) }
+      end
+    end
+  end
+end

data/lib/bug_bunny/consumer_middleware.rb

@@ -61,6 +61,19 @@ module BugBunny
         self
       end
 
+      # Registra un middleware al principio de la cadena, para que envuelva a todos los demás. Thread-safe.
+      #
+      # Es para lo que tiene que quedar afuera de todo sin depender del orden en que se registran los
+      # demás: {RailsExecutor} va primero porque limpia el estado por hilo al arrancar, y un middleware
+      # que carga ese estado antes que él (el de tracing de ExisRay) lo perdería.
+      #
+      # @param middleware_class [Class] Clase que hereda de {Base}.
+      # @return [self]
+      def prepend(middleware_class)
+        @mutex.synchronize { @middlewares.unshift(middleware_class) }
+        self
+      end
+
       # @return [Boolean] `true` si no hay middlewares registrados. Thread-safe.
       def empty?
         @mutex.synchronize { @middlewares.empty? }

data/lib/bug_bunny/railtie.rb

@@ -8,6 +8,7 @@ module BugBunny
   # Esta clase es responsable de:
   # 1. Registrar la carpeta `app/rabbit` en el autoloader de Rails (Zeitwerk).
   # 2. Gestionar la seguridad de las conexiones durante el "forking" de procesos (Puma/Spring).
+  # 3. Envolver cada mensaje del Consumer con el executor de Rails (ver {ConsumerMiddleware::RailsExecutor}).
   #
   # @see https://guides.rubyonrails.org/engines.html#railtie
   class Railtie < ::Rails::Railtie
@@ -34,12 +35,27 @@ module BugBunny
       end
     end
 
-    # 3. Rake tasks (bug_bunny:sync)
+    # 3. Executor de Rails alrededor de cada mensaje del Consumer
+    #
+    # El Consumer procesa en el hilo de Bunny, que Rails no conoce: sin esto, el estado por hilo
+    # pasa de un mensaje al siguiente. Va al principio de la cadena (`prepend`, no `use`) para que
+    # envuelva también a los middlewares que cargan ese estado, como el de tracing de ExisRay, que
+    # se registra en su propio `after_initialize` y en un orden que no controlamos.
+    config.after_initialize do
+      # Sin un `BugBunny.configure` previo, vale la configuración por default; un `configure` posterior la reusa.
+      BugBunny.configuration ||= BugBunny::Configuration.new
+      if BugBunny.configuration.consumer_rails_executor
+        require_relative 'consumer_middleware/rails_executor'
+        BugBunny.consumer_middlewares.prepend(BugBunny::ConsumerMiddleware::RailsExecutor)
+      end
+    end
+
+    # 4. Rake tasks (bug_bunny:sync)
     rake_tasks do
       load File.expand_path('../tasks/bug_bunny.rake', __dir__)
     end
 
-    # 4. Hook de Spring (Preloader)
+    # 5. Hook de Spring (Preloader)
     if defined?(Spring)
       Spring.after_fork do
         BugBunny.disconnect

data/lib/bug_bunny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BugBunny
-  VERSION = '5.2.0'
+  VERSION = '5.3.0'
 end

data/skill/SKILL.md

@@ -19,10 +19,12 @@ Gema Ruby: capa de routing RESTful sobre AMQP/RabbitMQ. Microservicios se comuni
 
 ## Contrato resumido (piso mínimo)
 
-> Resume el contrato de **`bug_bunny` 5.2.0** (anclado a `v5.2.0`). Suficiente para el uso típico sin abrir el detalle; el detalle version-locked está en el **Índice de artefactos** de abajo. Antipatrones/API completa: más abajo (embebido interim, ver Cobertura y fronteras).
+> Resume el contrato de **`bug_bunny` 5.3.0** (anclado a `v5.3.0`). Suficiente para el uso típico sin abrir el detalle; el detalle version-locked está en el **Índice de artefactos** de abajo. Antipatrones/API completa: más abajo (embebido interim, ver Cobertura y fronteras).
 >
 > **Si venís de 5.1.x, un cambio de conducta (5.2.0):** una entrega cuyo middleware —o `handle_fatal_error`— levanta **antes del ack** ahora se **rechaza sin requeue** (evento `consumer.delivery_failed`), en `subscribe` y en `drain`. Antes quedaba sin ack ni reject y trababa el consumidor. Si un middleware levantaba a propósito para que el mensaje se reintentara, ahora el mensaje se pierde: el reintento es tuyo. Detalle en [`docs/behavior/behavior.md`](../docs/behavior/behavior.md).
 >
+> **Si venís de 5.2.x, dos cambios de conducta dentro de Rails (5.3.0):** cada mensaje del Consumer corre dentro de `Rails.application.executor.wrap`. En Rails ≥ 7.0, un error que escapa del mensaje además se reporta a `Rails.error` (el mensaje se sigue rechazando sin requeue), y la caché de queries de ActiveRecord queda prendida durante cada mensaje. Se apagan con `config.consumer_rails_executor = false`. Detalle en [`docs/behavior/behavior.md`](../docs/behavior/behavior.md) y [`docs/config/configuracion.md`](../docs/config/configuracion.md).
+>
 > **Si venís de 4.x, dos breaking a mirar antes de subir:** `5.0.0` eliminó la constante pública `BugBunny::SecurityError` (un `rescue BugBunny::SecurityError` que sobreviva revienta con `NameError` y **enmascara la excepción original**) y `4.18.0` cambió el wrapping `Bunny::Exception` → `CommunicationError`. Detalle en `CHANGELOG.md`.
 
 **Símbolos públicos clave**
@@ -63,16 +65,16 @@ client.publish('events', body: { type: 'x' })   # => { 'status' => 202 }
 
 ## Índice de artefactos (fuente de verdad)
 
-El detalle vive en `docs/<capa>/` (modelo `dev-*`); esta skill **indexa y resume**, no duplica. Links relativos = version-locked (mismo tag del release, `v5.2.0`; `gemspec.files` incluye `docs/**`, así que estos archivos viajan dentro del `.gem` que ya tenés instalado).
+El detalle vive en `docs/<capa>/` (modelo `dev-*`); esta skill **indexa y resume**, no duplica. Links relativos = version-locked (mismo tag del release, `v5.3.0`; `gemspec.files` incluye `docs/**`, así que estos archivos viajan dentro del `.gem` que ya tenés instalado).
 
 | Capa | Artefacto | Estado |
 |---|---|---|
 | Glosario de dominio | [docs/glossary/glossary.md](../docs/glossary/glossary.md) | parcial, acreta por PR |
-| Comportamiento (flujos) | [docs/behavior/behavior.md](../docs/behavior/behavior.md) | completa — 6 flujos |
+| Comportamiento (flujos) | [docs/behavior/behavior.md](../docs/behavior/behavior.md) | completa — 8 flujos |
 | Configuración | [docs/config/configuracion.md](../docs/config/configuracion.md) | §a-§e/§i estructura + §f/§g/§h enrich — completa |
 | Dependencias consumidas | [docs/consumed/rabbitmq.md](../docs/consumed/rabbitmq.md) | §a/§b/§d estructura + §c/§e enrich |
 | Errores | [docs/errors/errors.md](../docs/errors/errors.md) | §a/§b/§d completas; §c política inferida (verificación humana pendiente) |
-| Test | [docs/test/testing.md](../docs/test/testing.md) | §a-§h — 16 unit / 7 integration |
+| Test | [docs/test/testing.md](../docs/test/testing.md) | §a-§h — 18 unit / 8 integration / 1 rails (`spec/rails/`, en su propio proceso) |
 | Release | [docs/release/release.md](../docs/release/release.md) | completa (régimen gema: build→publish; §e/f/g n/a) |
 | Datos | — | n/a — gema sin DB |
 | Eventos | — | n/a — la gema **es** el transporte; no declara catálogo de eventos de dominio propio |
@@ -139,7 +141,8 @@ Por RFC-008 §2: no se fabrica la capa, no se borra contrato sin destino, no se
 | `BugBunny::Producer` | Publica mensajes. Implementa tres modos: `#fire` (async), `#confirmed` (sync con `wait_for_confirms`) y `#rpc` (direct reply-to + `Concurrent::IVar`). |
 | `BugBunny::Client` | API de alto nivel. Pool de conexiones y middleware stack (onion architecture). |
 | `BugBunny::Consumer` | Subscribe loop con health check. Rutea mensajes via `BugBunny.routes`. |
-| `BugBunny::ConsumerMiddleware::Stack` | Pipeline de middlewares antes de `process_message`. Thread-safe. |
+| `BugBunny::ConsumerMiddleware::Stack` | Pipeline de middlewares antes de `process_message`. Thread-safe. `use` agrega al final; `prepend` pone al principio (envuelve a todos). |
+| `BugBunny::ConsumerMiddleware::RailsExecutor` | Sólo en Rails: envuelve cada mensaje con `Rails.application.executor.wrap`, para que el estado por hilo (`CurrentAttributes`, conexión de AR) no pase al siguiente. Lo registra el Railtie primero; se apaga con `config.consumer_rails_executor = false`. |
 | `BugBunny::Controller` | Base class tipo Rails. `before_action`, `around_action`, `after_action`, `rescue_from`, `render`. |
 | `BugBunny::Resource` | ORM sobre AMQP. `find`, `where`, `create`, `save`, `destroy`. ActiveModel validations y callbacks. |
 | `BugBunny::Routing::RouteSet` | DSL de rutas: `resources`, `namespace`, `member`, `collection`. |
@@ -147,7 +150,7 @@ Por RFC-008 §2: no se fabrica la capa, no se borra contrato sin destino, no se
 | `BugBunny::Middleware::Stack` | Builder de middlewares client-side (onion architecture tipo Faraday). |
 | BugBunny::Request | Value object del mensaje saliente con metadata AMQP completa. |
 | BugBunny::OTel | Helpers para emitir campos siguiendo las OTel semantic conventions for messaging. |
-| BugBunny::Railtie | Integración Rails: autoload de `app/rabbit`, fork safety (Puma, Spring). |
+| BugBunny::Railtie | Integración Rails: autoload de `app/rabbit`, fork safety (Puma, Spring), executor de Rails alrededor de cada mensaje del Consumer. |
 
 ---
 
@@ -386,6 +389,9 @@ Cada slot del pool cachea su `Session` y `Producer` durante su vida útil. Esto
 ### ¿Cómo funciona fork safety?
 `BugBunny::Railtie` registra hooks en `ActiveSupport::ForkTracker` (Rails 7.1+), `Puma.events.on_worker_boot` y `Spring.after_fork` para llamar `BugBunny.disconnect` y evitar sockets TCP heredados.
 
+### ¿Por qué el estado de un mensaje no pasa al siguiente?
+El Consumer procesa en el hilo de trabajo de Bunny, que Rails no conoce. En Rails, el Railtie registra `ConsumerMiddleware::RailsExecutor` al principio de la cadena (`prepend`), que envuelve cada mensaje con `Rails.application.executor.wrap`: al entrar y al salir se resetean los `CurrentAttributes`, y al salir la conexión de ActiveRecord vuelve al pool. Va primero para envolver también a los middlewares que cargan estado por hilo (el de tracing de ExisRay). **Cambios de conducta:** en Rails ≥ 7.0, un error que escapa del mensaje además se reporta a `Rails.error` con `handled: false` (el mensaje se sigue rechazando sin requeue); y la caché de queries de AR queda prendida durante cada mensaje (en el hilo de Bunny estaba apagada). Apagado: `config.consumer_rails_executor = false`.
+
 ---
 
 ## Antipatrones

data/skill/references/consumer.md

@@ -87,6 +87,15 @@ BugBunny.configuration.consumer_middlewares.use MyTracing::Middleware
 BugBunny.configuration.consumer_middlewares.use MyAuth::Middleware
 ```
 
+`use` agrega al final de la cadena; `prepend` pone al principio, envolviendo a todos.
+
+### Executor de Rails (automático en Rails)
+
+En Rails, el Railtie registra `BugBunny::ConsumerMiddleware::RailsExecutor` **primero**: cada mensaje corre dentro
+de `Rails.application.executor.wrap`, así que los `CurrentAttributes` no pasan de un mensaje al siguiente y la
+conexión de ActiveRecord vuelve al pool. Cambios de conducta: en Rails ≥ 7.0, un error que escapa del mensaje además
+se reporta a `Rails.error`, y la caché de queries de AR queda prendida durante cada mensaje. Se apaga con `config.consumer_rails_executor = false` (desde `config/initializers`).
+
 ### Crear Middleware
 
 ```ruby

data/skill/references/testing.md

@@ -131,7 +131,10 @@ TEST_POOL = ConnectionPool.new(size: 5) { BugBunny.create_connection }
 ## Ejecutar Tests
 
 ```bash
-bundle exec rspec                           # Todos
+bundle exec rake                            # Todos: spec/ y spec/rails/ (cada una en su proceso)
+bundle exec rspec                           # spec/, sin Rails (.rspec excluye spec/rails/ si no se la pide)
+bundle exec rspec spec/rails                # Solo el Railtie (igual que rake spec:rails)
+bundle exec rake spec:rails                 # Solo el Railtie, con una app Rails mínima
 bundle exec rspec spec/unit/                # Solo unit
 bundle exec rspec spec/integration/         # Solo integration (requiere RabbitMQ)
 bundle exec rspec spec/unit/session_spec.rb # Archivo específico

data/spec/rails/app.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# App Rails mínima para probar el Railtie de BugBunny con Rails de verdad (ActiveRecord sobre SQLite
+# en memoria).
+#
+# Rails se inicializa una vez por proceso, así que estos specs corren en su propio proceso
+# (`rake spec:rails`): la suite de `spec/` sigue probando la gema fuera de Rails. Para bootear con
+# otra configuración, el spec corre este archivo solo, en un subproceso (`ruby spec/rails/app.rb`),
+# y lee la cadena de middlewares que imprime.
+#
+# `BUG_BUNNY_SPEC_EXECUTOR=off` bootea con `config.consumer_rails_executor = false`.
+# `BUG_BUNNY_SPEC_CONFIGURE=none` bootea sin llamar a `BugBunny.configure` ni registrar otros middlewares:
+# la configuración queda la de default.
+
+ENV['RAILS_ENV'] = 'test'
+ENV['DATABASE_URL'] = 'sqlite3::memory:'
+
+require 'bundler/setup'
+require 'logger'
+require 'rails'
+require 'active_record/railtie'
+require 'bug_bunny'
+
+module BugBunnyRailsSpec
+  # La app: sin archivos de configuración propios, todo acá.
+  class Application < Rails::Application
+    config.root = __dir__
+    config.eager_load = false
+    config.logger = Logger.new(nil)
+    config.secret_key_base = 'bug_bunny-rails-spec'
+  end
+
+  # Lo que un mensaje deja por hilo: lo que los specs miran pasar (o no) al siguiente.
+  class LeftoverState < ActiveSupport::CurrentAttributes
+    attribute :value
+  end
+
+  # Contexto de traza, como el `ExisRay::Tracer` de ExisRay: un `CurrentAttributes`.
+  class TraceContext < ActiveSupport::CurrentAttributes
+    attribute :trace_id
+  end
+
+  # Un middleware que carga estado por hilo antes de procesar el mensaje y lo limpia al salir, como
+  # el de tracing de ExisRay. Se registra ANTES de que el Railtie de BugBunny registre el suyo: es el
+  # orden que hace falta para ver si el executor lo borra.
+  class TracingMiddleware < BugBunny::ConsumerMiddleware::Base
+    def call(delivery_info, properties, body)
+      TraceContext.trace_id = 'from-tracing'
+      @app.call(delivery_info, properties, body)
+    ensure
+      TraceContext.reset
+    end
+  end
+end
+
+unless ENV['BUG_BUNNY_SPEC_CONFIGURE'] == 'none'
+  BugBunny.configure do |config|
+    config.logger = Logger.new(nil)
+    # El `respond_to?` deja correr estos specs contra una versión de la gema sin la opción, para ver
+    # que fallan sin el cambio.
+    if config.respond_to?(:consumer_rails_executor=)
+      config.consumer_rails_executor = ENV['BUG_BUNNY_SPEC_EXECUTOR'] != 'off'
+    end
+  end
+  BugBunny.consumer_middlewares.use(BugBunnyRailsSpec::TracingMiddleware)
+end
+
+BugBunnyRailsSpec::Application.initialize!
+
+puts BugBunny.consumer_middlewares.instance_variable_get(:@middlewares).map(&:name) if $PROGRAM_NAME == __FILE__

data/spec/rails/consumer_rails_executor_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative 'rails_helper'
+require 'open3'
+
+# Cada mensaje del Consumer corre dentro del executor de Rails (sequre/bug_bunny#70).
+#
+# Las entregas se procesan en un hilo propio, como el hilo de trabajo de Bunny: Rails no lo conoce.
+RSpec.describe 'BugBunny::ConsumerMiddleware::RailsExecutor' do
+  let(:channel) do
+    double('channel').tap do |ch|
+      allow(ch).to receive(:ack)
+      allow(ch).to receive(:reject)
+      allow(ch).to receive(:open?).and_return(true)
+    end
+  end
+
+  let(:consumer) do
+    session = instance_double(BugBunny::Session, channel: channel, close: nil)
+    described_consumer = BugBunny::Consumer.new(double('connection'))
+    described_consumer.instance_variable_set(:@session, session)
+    described_consumer
+  end
+
+  let(:properties) do
+    double('properties', type: 'probe/show', headers: { 'x-http-method' => 'GET' },
+                         correlation_id: 'corr-1', reply_to: nil, content_type: 'application/json')
+  end
+
+  # Lo que hace la acción del controller en cada entrega.
+  let(:on_message) { -> {} }
+
+  before do
+    allow(BugBunny.routes).to receive(:recognize)
+      .and_return({ controller: 'probe', action: 'show', params: {}, namespace: nil })
+
+    handler = on_message
+    stub_const('BugBunny::Controllers::ProbeController', Class.new(BugBunny::Controller) do
+      define_method(:show) do
+        handler.call
+        render status: 200, json: {}
+      end
+    end)
+  end
+
+  # Procesa las entregas en orden, en un hilo propio (como el de Bunny).
+  def deliver_on_a_bunny_like_thread(*tags)
+    Thread.new do
+      tags.each do |tag|
+        delivery_info = double('delivery_info', exchange: 'x', routing_key: 'probe', delivery_tag: tag,
+                                                redelivered?: false)
+        yield(:before, tag) if block_given?
+        consumer.send(:handle_delivery, delivery_info, properties, '{}')
+        yield(:after, tag) if block_given?
+      end
+    end.join
+  end
+
+  it 'queda primero en la cadena, antes del middleware de tracing registrado antes que él' do
+    middlewares = BugBunny.consumer_middlewares.instance_variable_get(:@middlewares).map(&:name)
+
+    expect(middlewares).to eq(%w[BugBunny::ConsumerMiddleware::RailsExecutor BugBunnyRailsSpec::TracingMiddleware])
+  end
+
+  describe 'el estado por hilo no pasa de un mensaje al siguiente' do
+    let(:seen) { [] }
+    let(:on_message) do
+      lambda do
+        seen << BugBunnyRailsSpec::LeftoverState.value
+        BugBunnyRailsSpec::LeftoverState.value = 'left by the previous message'
+      end
+    end
+
+    it 'el segundo mensaje arranca sin lo que el primero dejó en un CurrentAttributes' do
+      deliver_on_a_bunny_like_thread(1, 2)
+
+      expect(seen).to eq([nil, nil])
+    end
+  end
+
+  describe 'la conexión de ActiveRecord' do
+    # Si el hilo tiene una conexión tomada del pool (en Rails 8.1, `active_connection?` devuelve la
+    # conexión, o nil).
+    def connection_leased?
+      ActiveRecord::Base.connection_pool.active_connection?.present?
+    end
+
+    let(:inside) { [] }
+    let(:on_message) do
+      lambda do
+        ActiveRecord::Base.connection.execute('SELECT 1')
+        inside << connection_leased?
+      end
+    end
+
+    it 'vuelve al pool al terminar el mensaje que la usó' do
+      after = []
+      deliver_on_a_bunny_like_thread(1) do |moment, _tag|
+        after << connection_leased? if moment == :after
+      end
+
+      expect(inside).to eq([true]) # el mensaje la usó
+      expect(after).to eq([false]) # y al terminar ya no la tiene el hilo
+    end
+  end
+
+  describe 'un middleware que carga estado antes que el executor' do
+    let(:seen) { [] }
+    let(:on_message) { -> { seen << BugBunnyRailsSpec::TraceContext.trace_id } }
+
+    it 'conserva ese estado dentro del mensaje: el executor lo envuelve y no lo borra' do
+      deliver_on_a_bunny_like_thread(1)
+
+      expect(seen).to eq(['from-tracing'])
+    end
+  end
+
+  describe 'un error que escapa del procesamiento del mensaje' do
+    let(:reports) { [] }
+    let(:subscriber) do
+      collected = reports
+      Class.new do
+        define_method(:report) { |error, handled:, **| collected << [error.message, handled] }
+      end.new
+    end
+
+    before { Rails.error.subscribe(subscriber) }
+    after { Rails.error.unsubscribe(subscriber) if Rails.error.respond_to?(:unsubscribe) } # no existe en Rails 7.0
+
+    it 'termina en un reject sin requeue, como hoy, y además se reporta a Rails.error' do
+      allow(consumer).to receive(:process_message).and_raise(RuntimeError, 'boom')
+
+      deliver_on_a_bunny_like_thread(7)
+
+      expect(channel).to have_received(:reject).with(7, false)
+      expect(reports).to eq([['boom', false]])
+    end
+  end
+
+  describe 'config.consumer_rails_executor' do
+    # Rails se inicializa una vez por proceso: la app se bootea de nuevo en un subproceso.
+    # Las líneas de stdout que nombran un middleware: un warning del entorno no las rompe.
+    def middlewares_after_boot(env)
+      app = File.expand_path('app.rb', __dir__)
+      stdout, stderr, status = Open3.capture3(env, RbConfig.ruby, app)
+      raise "la app no booteó:\n#{stderr}" unless status.success?
+
+      stdout.lines.map(&:strip).grep(/\ABugBunny/)
+    end
+
+    it 'con false, no registra el middleware' do
+      expect(middlewares_after_boot('BUG_BUNNY_SPEC_EXECUTOR' => 'off')).to eq(['BugBunnyRailsSpec::TracingMiddleware'])
+    end
+
+    it 'con true, lo registra primero' do
+      expect(middlewares_after_boot('BUG_BUNNY_SPEC_EXECUTOR' => 'on'))
+        .to eq(%w[BugBunny::ConsumerMiddleware::RailsExecutor BugBunnyRailsSpec::TracingMiddleware])
+    end
+
+    it 'sin BugBunny.configure previo, bootea y lo registra: la opción ausente vale su default' do
+      expect(middlewares_after_boot('BUG_BUNNY_SPEC_CONFIGURE' => 'none'))
+        .to eq(['BugBunny::ConsumerMiddleware::RailsExecutor'])
+    end
+  end
+end

data/spec/rails/rails_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Helper de los specs que corren dentro de Rails. Se carga sólo desde `rake spec:rails`, en un
+# proceso aparte del resto de la suite (ver spec/rails/app.rb).
+
+require_relative 'app'

data/spec/unit/configuration_spec.rb

@@ -188,6 +188,12 @@ RSpec.describe BugBunny::Configuration do
     end
   end
 
+  describe 'consumer_rails_executor flag' do
+    it 'tiene default true (el Railtie envuelve cada mensaje con el executor de Rails)' do
+      expect(BugBunny::Configuration.new.consumer_rails_executor).to be(true)
+    end
+  end
+
   describe 'nack_raise flag' do
     it 'tiene default true (raise PublishNacked en NACK)' do
       expect(BugBunny::Configuration.new.nack_raise).to be(true)

data/spec/unit/consumer_middleware_spec.rb

@@ -47,6 +47,19 @@ RSpec.describe BugBunny::ConsumerMiddleware::Stack do
     end
   end
 
+  describe '#prepend' do
+    it 'registra el middleware al principio: envuelve a los ya registrados' do
+      log = []
+      stack.use(tracking_middleware(log, :a))
+      result = stack.prepend(tracking_middleware(log, :first))
+
+      stack.call(delivery_info, properties, body) { log << :core }
+
+      expect(result).to be(stack)
+      expect(log).to eq(%i[first_before a_before core a_after first_after])
+    end
+  end
+
   describe '#empty?' do
     it 'retorna true cuando no hay middlewares' do
       expect(stack.empty?).to be(true)

data/spec/unit/consumer_rails_executor_outside_rails_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# Fuera de Rails la gema se comporta como antes de sequre/bug_bunny#70: el middleware del executor
+# lo registra el Railtie, y el Railtie no se carga.
+RSpec.describe 'BugBunny fuera de Rails' do
+  it 'no carga el Railtie' do
+    expect(defined?(Rails)).to be_nil
+    expect(defined?(BugBunny::Railtie)).to be_nil
+  end
+
+  it 'no carga el middleware del executor ni lo pone en la cadena del Consumer' do
+    middlewares = BugBunny.consumer_middlewares.instance_variable_get(:@middlewares).map(&:name)
+
+    expect(defined?(BugBunny::ConsumerMiddleware::RailsExecutor)).to be_nil
+    expect(middlewares).not_to include('BugBunny::ConsumerMiddleware::RailsExecutor')
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 5.2.0
+  version: 5.3.0
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-29 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -220,6 +220,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
 description: BugBunny is a lightweight RPC framework for Ruby on Rails over RabbitMQ.
   It simulates a RESTful architecture with an intelligent router, Active Record-like
   resources, and middleware support.
@@ -229,6 +271,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rspec"
 - AGENTS.md
 - CHANGELOG.md
 - CLAUDE.md
@@ -247,6 +290,7 @@ files:
 - lib/bug_bunny/configuration.rb
 - lib/bug_bunny/consumer.rb
 - lib/bug_bunny/consumer_middleware.rb
+- lib/bug_bunny/consumer_middleware/rails_executor.rb
 - lib/bug_bunny/controller.rb
 - lib/bug_bunny/drain_tracker.rb
 - lib/bug_bunny/exception.rb
@@ -287,6 +331,9 @@ files:
 - spec/integration/infrastructure_spec.rb
 - spec/integration/publisher_confirms_spec.rb
 - spec/integration/resource_spec.rb
+- spec/rails/app.rb
+- spec/rails/consumer_rails_executor_spec.rb
+- spec/rails/rails_helper.rb
 - spec/spec_helper.rb
 - spec/support/bunny_mocks.rb
 - spec/support/integration_helper.rb
@@ -294,6 +341,7 @@ files:
 - spec/unit/communication_error_wrapping_spec.rb
 - spec/unit/configuration_spec.rb
 - spec/unit/consumer_middleware_spec.rb
+- spec/unit/consumer_rails_executor_outside_rails_spec.rb
 - spec/unit/consumer_spec.rb
 - spec/unit/controller_after_action_spec.rb
 - spec/unit/drain_tracker_spec.rb
@@ -317,7 +365,7 @@ metadata:
   homepage_uri: https://github.com/gedera/bug_bunny
   source_code_uri: https://github.com/gedera/bug_bunny
   changelog_uri: https://github.com/gedera/bug_bunny/blob/main/CHANGELOG.md
-  documentation_uri: https://github.com/gedera/bug_bunny/blob/v5.2.0/skill
+  documentation_uri: https://github.com/gedera/bug_bunny/blob/v5.3.0/skill
 post_install_message:
 rdoc_options: []
 require_paths: