bug_bunny 4.17.1 → 4.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50bb70f17d783b52abeb208bc362953c9494b61853f836da84f73552e3a76966
-  data.tar.gz: 37f9550b64942b1e544a6e7d593c1695f1293c6a1b488e1b0bec3179d1f3b7a4
+  metadata.gz: 030517babaaafccb4ac6b067e1c11ac1cf6d4a6a711919c8455c3dcfe6a79637
+  data.tar.gz: fb9a551e05882e05efc3cd23215773507ae6d5d2baab70681360c04100724d29
 SHA512:
-  metadata.gz: 4733c50dcb6824c4e7d53bc0842e823b0674c13bf6cd9d963f99b6fa090166d083ca64cc6e65eba2fc29bff09be840772a6404fae19e62f3dd9b6dbcf56fc2d3
-  data.tar.gz: e9613f65b4bce0ad19aa8c19f259c6a3069ba4dfe185e4146a5992ddfbd20b3428816ed882e9d637f2b4a85d1d5d307094763bf8f3082900e8c6d9d3fe8a1fb7
+  metadata.gz: a5c4fbaade4883c361a20e705155d2b60dc6b3e6e64905afe34b02a7a7016cd7913bfd9f1f2de09979d357f72b026dbdc3129ad871d128a1b9ee901628a096b6
+  data.tar.gz: fb7b8dd6f7b74dee3c6d13b789dd07ff3abaeda535680a1ab7ea4276269e40a238588403e5fd7c8d2cdb3188acd3b7889d867d4dffed6a19af45d91eefa68591

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [4.18.0] - 2026-05-26
+
+> Behavior change menor: cualquier `Bunny::Exception` que escape en la frontera del gem (TCP fail, conn rota, canal cerrado, auth fail) ahora se envuelve como `BugBunny::CommunicationError`. La excepción original queda accesible vía `.cause`. Callers que rescatan `Bunny::TCPConnectionFailed` directo deben migrar a `BugBunny::CommunicationError`. Callers que ya rescatan `BugBunny::Error` / `CommunicationError`: sin cambios.
+
+### Correcciones
+- **`Client#publish`/`#request`/`#send` leak de `Bunny::TCPConnectionFailedForAllHosts` (#49):** el TCP fail nacía en `ConnectionPool::TimedStack#try_create` dentro de `@pool.with`, antes de entrar al `Producer#confirmed` que ya envolvía con `rescue StandardError`. `Client#run_in_pool` ahora envuelve cualquier `Bunny::Exception` → `BugBunny::CommunicationError` (cubre también `Bunny::ConnectionClosedError` in-flight sobre conn rota mid-publish). `BugBunny.create_connection` también envuelve (Railtie, scripts, tests). YARD `@raise` actualizado. — @Gabriel
+
+### Mejoras internas
+- `Producer#confirmed` rescue estrechado de `rescue StandardError` a `rescue Bunny::Exception` — no traga bugs internos (`NoMethodError`, `KeyError`) bajo la etiqueta de fallo de transporte. — @Gabriel
+- `CommunicationError` docstring expandido: declara que envuelve cualquier `Bunny::Exception`, no solo TCP, y que `.cause` preserva la original. — @Gabriel
+- `Client#run_in_pool` refactor: extraído `execute_in_pool` privado para mantener `Metrics/AbcSize`. — @Gabriel
+
+### Documentación
+- `docs/behavior/behavior.md` refrescado scoped (RFC-001 §3.3.3 vía quality-code Paso 5): nota de contrato de error wrapping en flujos Fire-and-forget y Confirmed; nueva entrada en §3 Inferencias; verificación humana 2026-05-26. — @Gabriel
+- `README.md` y `skill/SKILL.md` re-indexados vía `dev-compose`: jerarquía de excepciones refinada, gotcha nuevo sobre errores de transporte 4.18+, descripción de `BugBunny::CommunicationError` en errores comunes. — @Gabriel
+
 ## [4.17.1] - 2026-05-19
 
 > Release docs-only sobre 4.17.0 — sin cambios en `lib/` ni API pública. Incorpora la familia de skills `dev-*` (RFC-001) y los artefactos de detalle version-locked (`docs/glossary`, `docs/behavior`) que viajan en el `.gem`.

data/README.md

@@ -377,7 +377,7 @@ BugBunny maps RabbitMQ responses to a semantic exception hierarchy, similar to h
 
 ```
 BugBunny::Error
-├── CommunicationError                  (network / channel failure)
+├── CommunicationError                  (wraps any Bunny::Exception — TCP/auth/channel — at the gem boundary; .cause preserves the original)
 ├── ConfigurationError                  (invalid config attribute)
 ├── SecurityError                       (unauthorized controller resolution)
 ├── PublishNacked                       (broker basic.nack on :confirmed publish)

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 `a5cdb10` · cobertura: completa (6 flujos) · verificado por humano 2026-05-18
+> meta: artefacto `comportamiento` · RFC-007 (cadencia incremental default / completo on-demand) · generado dev-enrich 1.3.0 (backfill on-demand) · anclado a `94de2b4` · cobertura: completa (6 flujos) · verificado por humano 2026-05-18 (base) · 2026-05-26 (refresco scoped: contrato de error wrapping post-#49)
 
 ## 1. Resumen
 
@@ -68,6 +68,8 @@ sequenceDiagram
 ```
 Contexto: `client.rb:129-134` → `producer.rb:47-51` → `publish_message producer.rb:146-161`.
 
+**Errores (contrato cliente):** cualquier `Bunny::Exception` que escape durante `@pool.with` (TCP fail en `try_create`, `ConnectionClosedError` in-flight, `ChannelAlreadyClosed`, etc.) se envuelve como `BugBunny::CommunicationError` en `Client#run_in_pool` (`client.rb:155-167`). La excepción original queda en `.cause`. Los callers del `Client` no rescatan tipos `Bunny::*`.
+
 ### Flujo: Confirmed + basic.return bridge
 ACK del broker síncrono; `basic.return` (mandatory unroutable) llega en el reader thread de Bunny y se puentea al hilo de publish vía `@pending_returns` + `Concurrent::Event` con ventana de tolerancia GVL.
 
@@ -92,7 +94,7 @@ sequenceDiagram
     P-->>CL: PublishUnroutable (o éxito si slot vacío)
     Note over RT,S: on_return corre antes del raise · su excepción se loggea (no propaga)
 ```
-Contexto: `producer.rb:72-93,200-216,281-345`; `session.rb:70-74,204-250`. Branches: ack→ok · nack→`PublishNacked` (`producer.rb:235`) · return→`PublishUnroutable` (`producer.rb:325`) · timeout→`RequestTimeout` (`producer.rb:214-215`).
+Contexto: `producer.rb:72-93,200-216,281-345`; `session.rb:70-74,204-250`. Branches: ack→ok · nack→`PublishNacked` (`producer.rb:235`) · return→`PublishUnroutable` (`producer.rb:325`) · timeout→`RequestTimeout` (`producer.rb:214-215`) · canal/conn AMQP rota (`Bunny::Exception`)→`CommunicationError` (envuelta por `Producer#confirmed` `producer.rb:87-90` y/o `Client#run_in_pool` `client.rb:155-167`; `.cause` preserva la original).
 
 ### Flujo: Consumer subscribe loop + reconnect + health
 Loop bloqueante infinito con backoff exponencial + jitter en error; health check en TimerTask separado, **acoplado flojo** vía estado de session.
@@ -166,6 +168,7 @@ Contexto: `middleware/stack.rb:31-47` (build L43-47, `reverse.inject`), `base.rb
 | Secuencias y `file:line` extraídos por el LLM del código a `a5cdb10`; 2ª pasada LLM corrigió 3 discrepancias (flujo middleware invertido, timeout RPC `producer.rb:124`, timeout confirmed `producer.rb:214-215`) | confirmed | **verificado por humano 2026-05-18** (invariante RFC-001 §3.3 satisfecho) |
 | Orden wire `basic.return → basic.ack` garantizado por AMQP; `RETURN_RACE_WINDOW_S` cubre GVL | declared (código) / inferred (garantía AMQP) | confirmar lectura de `producer.rb:299-308` + spec AMQP |
 | Health check acoplado flojo al loop vía cierre de session | inferred | confirmar `consumer.rb:340-361` vs `106-124` |
+| Frontera de error del Client: cualquier `Bunny::Exception` durante `@pool.with` (try_create o in-flight) → `BugBunny::CommunicationError` con `.cause` preservada (`client.rb:155-167`). `Producer#confirmed` rescate estrechado a `Bunny::Exception` (`producer.rb:87-90`) — no traga bugs Ruby. `BugBunny.create_connection` también envuelve (`bug_bunny.rb:96-99`). | declared (código post-#49) | confirmar lectura de `client.rb:155-167`, `producer.rb:87-90`, `bug_bunny.rb:96-99` + specs `communication_error_wrapping_spec.rb` |
 
 ## 4. Cobertura y fronteras
 
@@ -173,4 +176,4 @@ Contexto: `middleware/stack.rb:31-47` (build L43-47, `reverse.inject`), `base.rb
 - **Lógica dispersa marcada (no fingida):** health check (thread aparte vía `Concurrent::TimerTask`, acople flojo con el loop sólo vía cierre de session). RFC-007: marcada, no diagramada como flujo limpio falso. (El orden onion del middleware NO es lógica dispersa: es mecanismo limpio y documentado en `stack.rb:37-39`.)
 - **Fuera de alcance:** estructura (operaciones/interfaz/topología) → dev-structure F2 (no implementado). Significado de términos → `glossary.md`. Datos → n/a (sin DB).
 - **Frescura:** PR que renombre/mueva un método citado → reviewer actualiza el diagrama y `file:line` en el mismo PR (RFC-001 §3.3).
-- **Verificación humana:** completada 2026-05-18 (invariante RFC-001 §3.3 satisfecho). Re-verificar en cada PR que toque un flujo citado (frescura).
+- **Verificación humana:** base completada 2026-05-18; refresco scoped 2026-05-26 (contrato de error wrapping post-#49 en Fire-and-forget y Confirmed; invariante RFC-001 §3.3 satisfecho). Re-verificar en cada PR que toque un flujo citado (frescura).

data/lib/bug_bunny/client.rb

@@ -138,9 +138,19 @@ module BugBunny
     # Ejecuta la lógica de envío dentro del contexto del Pool.
     # Mapea los argumentos al objeto Request y ejecuta la cadena de middlewares.
     #
+    # Cualquier `Bunny::Exception` que nazca durante la adquisición de la conexión
+    # (`@pool.with` → `try_create`) o durante operaciones sobre una conexión rota
+    # in-flight (canal cerrado, conn perdida) se envuelve en
+    # {BugBunny::CommunicationError}. Esto preserva el contrato de abstracción del
+    # gem: los callers del `Client` no deberían tener que rescatar tipos de
+    # `Bunny::*`. La excepción original queda accesible vía `.cause` (Ruby la
+    # preserva automáticamente al re-raisear dentro del `rescue`).
+    #
     # @param url [String] La ruta destino.
     # @param args [Hash] Argumentos pasados a los métodos públicos.
     # @yield [req] Bloque para configuración adicional del Request.
+    # @raise [BugBunny::CommunicationError] Si la conexión TCP/AMQP falla durante
+    #   la adquisición del slot del pool o durante la operación.
     def run_in_pool(url, args)
       req = build_request(url, args)
 
@@ -151,8 +161,19 @@ module BugBunny
       # de los keyword args. Evaluamos el warning sobre el estado final del Request.
       warn_return_raise_misuse(req)
 
-      # Ejecución dentro del Pool.
-      # Session y Producer se reutilizan por slot de conexión (ver #session_for / #producer_for).
+      execute_in_pool(req)
+    rescue BugBunny::Error
+      raise
+    rescue Bunny::Exception => e
+      raise BugBunny::CommunicationError, "AMQP failure on path=#{req&.path}: #{e.class}: #{e.message}"
+    end
+
+    # Ejecuta el Request dentro del Pool. Session y Producer se reutilizan por
+    # slot de conexión (ver #session_for / #producer_for).
+    #
+    # @param req [BugBunny::Request]
+    # @return [Hash] Respuesta del producer.
+    def execute_in_pool(req)
       @pool.with do |conn|
         session  = session_for(conn)
         producer = producer_for(conn, session)

data/lib/bug_bunny/exception.rb

@@ -7,8 +7,24 @@ module BugBunny
   # Permite capturar cualquier error de la librería con un `rescue BugBunny::Error`.
   class Error < ::StandardError; end
 
-  # Error lanzado cuando ocurren problemas de red o conexión con RabbitMQ.
-  # Suele envolver excepciones nativas de la gema `bunny` (ej: TCP connection failure).
+  # Error lanzado cuando ocurren problemas de red, conexión o protocolo AMQP con RabbitMQ.
+  #
+  # Envuelve cualquier `Bunny::Exception` (TCP fail, auth fail, canal cerrado,
+  # `PreconditionFailed`, `ConnectionClosedError`, etc.) en las fronteras de
+  # abstracción del gem — `BugBunny.create_connection`, `BugBunny::Client#publish` /
+  # `#request` / `#send`, y `BugBunny::Producer#confirmed`. Los callers no deberían
+  # rescatar tipos de `Bunny::*` directamente: con `rescue BugBunny::CommunicationError`
+  # alcanza para cubrir cualquier fallo de transporte/broker.
+  #
+  # La excepción original queda accesible vía `.cause` (Ruby la preserva
+  # automáticamente al re-raisear dentro del `rescue`).
+  #
+  # @example
+  #   begin
+  #     client.publish('evt', exchange: 'x', body: payload)
+  #   rescue BugBunny::CommunicationError => e
+  #     logger.error("publish failed: #{e.message} cause=#{e.cause&.class}")
+  #   end
   class CommunicationError < Error; end
 
   # Error lanzado cuando la configuración de la gema es inválida.

data/lib/bug_bunny/producer.rb

@@ -86,8 +86,8 @@ module BugBunny
       { 'status' => 202, 'body' => nil }
     rescue BugBunny::Error
       raise
-    rescue StandardError => e
-      raise BugBunny::CommunicationError, "Publisher confirms failed: #{e.message}"
+    rescue Bunny::Exception => e
+      raise BugBunny::CommunicationError, "Publisher confirms failed: #{e.class}: #{e.message}"
     ensure
       teardown_return_listener(request, return_listener)
     end

data/lib/bug_bunny/version.rb

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

data/lib/bug_bunny.rb

@@ -80,7 +80,10 @@ module BugBunny
   # @option options [Integer] :continuation_timeout (15000) Timeout para operaciones RPC internas.
   #
   # @return [Bunny::Session] Una sesión de Bunny ya iniciada (`start` ya invocado).
-  # @raise [Bunny::TCPConnectionFailed] Si no se puede conectar al servidor.
+  # @raise [BugBunny::CommunicationError] Si no se puede establecer la conexión
+  #   (TCP fail, auth fail, vhost inválido, etc.). Envuelve cualquier
+  #   `Bunny::Exception` para preservar la frontera de abstracción del gem.
+  #   La excepción original queda en `.cause`.
   def self.create_connection(**options)
     conn_options = merge_connection_options(options)
     Bunny.new(conn_options).tap do |conn|
@@ -89,6 +92,10 @@ module BugBunny
       end
       conn.start
     end
+  rescue Bunny::Exception => e
+    raise BugBunny::CommunicationError,
+          "Failed to establish AMQP connection to #{conn_options[:host]}:#{conn_options[:port]}: " \
+          "#{e.class}: #{e.message}"
   end
 
   # Cierra la conexión global si existe.

data/skill/SKILL.md

@@ -19,7 +19,7 @@ Gema Ruby: capa de routing RESTful sobre AMQP/RabbitMQ. Microservicios se comuni
 
 ## Contrato resumido (piso mínimo)
 
-> Resume el contrato de **`bug_bunny` 4.17.0**. Suficiente para el uso típico sin abrir el detalle; el detalle version-locked está en [`../docs/behavior/behavior.md`](../docs/behavior/behavior.md) (6 flujos) y [`../docs/glossary/glossary.md`](../docs/glossary/glossary.md) (símbolos→significado). Antipatrones/API completa: más abajo (embebido interim, ver Cobertura y fronteras).
+> Resume el contrato de **`bug_bunny` 4.18.0**. Suficiente para el uso típico sin abrir el detalle; el detalle version-locked está en [`../docs/behavior/behavior.md`](../docs/behavior/behavior.md) (6 flujos) y [`../docs/glossary/glossary.md`](../docs/glossary/glossary.md) (símbolos→significado). Antipatrones/API completa: más abajo (embebido interim, ver Cobertura y fronteras).
 
 **Símbolos públicos clave**
 
@@ -31,7 +31,7 @@ Gema Ruby: capa de routing RESTful sobre AMQP/RabbitMQ. Microservicios se comuni
 | `BugBunny::Controller` | `before/around/after_action`, `rescue_from`, `render status:, json:` |
 | `BugBunny.routes.draw` | `resources :x` · `namespace` · `member`/`collection` |
 | `BugBunny.configure` | `host/port/username/password` · `rpc_timeout` (default 10) · `nack_raise`/`return_raise` (default `true`) · `on_return` |
-| Excepciones | `RemoteError` (500 con backtrace remoto) · `PublishNacked` · `PublishUnroutable` · `RequestTimeout` · `NotFound` · `UnprocessableEntity` |
+| Excepciones | `RemoteError` (500 con backtrace remoto) · `PublishNacked` · `PublishUnroutable` · `RequestTimeout` · `NotFound` · `UnprocessableEntity` · `CommunicationError` (envuelve cualquier `Bunny::Exception` — TCP/conn/canal; `.cause` preserva original) |
 
 **Uso típico**
 
@@ -54,6 +54,7 @@ client.publish('events', body: { type: 'x' })   # => { 'status' => 202 }
 - `confirmed:true + mandatory:true` con `return_raise` (default `true`) → `PublishUnroutable` si no rutea.
 - `BugBunny::Consumer.subscribe` requiere `connection:`. No correr el Consumer en threads de Puma (loop bloqueante).
 - `exchange_options: { durable: true }` debe matchear la declaración del consumer, o `Bunny::PreconditionFailed`.
+- **Errores de transporte (4.18+):** TCP fail, conn rota, canal cerrado → siempre `BugBunny::CommunicationError`. No rescatar `Bunny::TCPConnectionFailed`/`ConnectionClosedError` directo — quedó atrás de la frontera. La original sigue accesible vía `.cause`.
 
 ## Índice de artefactos (fuente de verdad)
 
@@ -431,8 +432,8 @@ Limitación de RSpec: `instance_double` valida que el método exista pero **no**
 **Resolución:** `rescue BugBunny::RemoteError => e` y acceder a `e.original_class`, `e.original_message`, `e.original_backtrace`. Revisar logs del consumer (`event=controller.unhandled_exception`).
 
 ### BugBunny::CommunicationError
-**Causa:** Fallo de conexión o reconexión agotada.
-**Resolución:** Verificar conectividad a RabbitMQ. Revisar `max_reconnect_attempts` y logs de reconexión.
+**Causa:** Fallo de transporte AMQP — envuelve cualquier `Bunny::Exception` que escape en la frontera del gem (`Client#publish`/`#request`/`#send`, `Producer#confirmed`, `BugBunny.create_connection`). Cubre TCP fail (`Bunny::TCPConnectionFailed`), conn rota in-flight (`ConnectionClosedError`), canal cerrado (`ChannelAlreadyClosed`), auth fail, etc. La excepción original queda en `.cause`.
+**Resolución:** Verificar conectividad a RabbitMQ (host/port/auth/vhost). Inspeccionar `e.cause` para clasificar el fallo concreto. Revisar `max_reconnect_attempts` y logs de reconexión.
 
 Ver catálogo completo en [Errores](references/errores.md).
 

data/spec/unit/communication_error_wrapping_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/bunny_mocks'
+
+# Specs para el contrato de envoltura definido en issue #49:
+# cualquier `Bunny::Exception` que escape de las fronteras de abstracción del
+# gem (`BugBunny.create_connection`, `BugBunny::Client#publish`/`#request`/`#send`,
+# `BugBunny::Producer#confirmed`) debe re-raisearse como
+# `BugBunny::CommunicationError`, preservando la excepción original en `.cause`.
+RSpec.describe 'Bunny::Exception → BugBunny::CommunicationError wrapping' do
+  include BunnyMocks
+
+  describe 'BugBunny.create_connection' do
+    before { BugBunny.configuration ||= BugBunny::Configuration.new }
+
+    it 'envuelve Bunny::TCPConnectionFailedForAllHosts en CommunicationError' do
+      fake_session = instance_double(Bunny::Session)
+      allow(fake_session).to receive(:after_recovery_completed)
+      allow(fake_session).to receive(:start).and_raise(Bunny::TCPConnectionFailedForAllHosts)
+      allow(Bunny).to receive(:new).and_return(fake_session)
+
+      err = capture_error { BugBunny.create_connection(host: 'broker.invalid', port: 5672) }
+      expect(err).to be_a(BugBunny::CommunicationError)
+      expect(err.message).to match(/broker.invalid:5672/)
+      expect(err.cause).to be_a(Bunny::TCPConnectionFailed)
+    end
+
+    it 'envuelve cualquier Bunny::Exception, no solo TCP' do
+      fake_session = instance_double(Bunny::Session)
+      allow(fake_session).to receive(:after_recovery_completed)
+      allow(fake_session).to receive(:start).and_raise(Bunny::AuthenticationFailureError.new('guest', '/', 0))
+      allow(Bunny).to receive(:new).and_return(fake_session)
+
+      err = capture_error { BugBunny.create_connection }
+      expect(err).to be_a(BugBunny::CommunicationError)
+      expect(err.cause).to be_a(Bunny::AuthenticationFailureError)
+    end
+  end
+
+  describe 'Client#publish — TCP fail en try_create (issue #49 caso original)' do
+    it 'envuelve Bunny::TCPConnectionFailedForAllHosts levantado dentro de @pool.with' do
+      # Pool falso que levanta la excepción raw de bunny al adquirir slot —
+      # simula exactamente lo observado en producción en el stack trace del issue.
+      raising_pool = Object.new
+      raising_pool.define_singleton_method(:with) { |&_block| raise Bunny::TCPConnectionFailedForAllHosts }
+
+      client = BugBunny::Client.new(pool: raising_pool)
+
+      err = capture_error { client.publish('evt', exchange: 'x', exchange_type: 'direct', body: { a: 1 }) }
+      expect(err).to be_a(BugBunny::CommunicationError)
+      expect(err.message).to match(/AMQP failure on path=evt/)
+      expect(err.cause).to be_a(Bunny::TCPConnectionFailed)
+    end
+  end
+
+  describe 'Client — in-flight ConnectionClosedError' do
+    it 'envuelve Bunny::ConnectionClosedError levantado por el Producer' do
+      conn    = BunnyMocks::FakeConnection.new(true, BunnyMocks::FakeChannel.new(true))
+      pool    = Object.new.tap { |p| p.define_singleton_method(:with) { |&blk| blk.call(conn) } }
+      client  = BugBunny::Client.new(pool: pool)
+
+      allow_any_instance_of(BugBunny::Producer).to receive(:fire)
+        .and_raise(Bunny::ConnectionClosedError.new('connection lost'))
+
+      err = capture_error { client.publish('evt', exchange: 'x', exchange_type: 'direct', body: { a: 1 }) }
+      expect(err).to be_a(BugBunny::CommunicationError)
+      expect(err.message).to match(/AMQP failure/)
+      expect(err.cause).to be_a(Bunny::ConnectionClosedError)
+    end
+  end
+
+  describe 'Client — pass-through de BugBunny::Error' do
+    it 'no re-envuelve errores propios del gem (RequestTimeout, PublishNacked, etc.)' do
+      conn    = BunnyMocks::FakeConnection.new(true, BunnyMocks::FakeChannel.new(true))
+      pool    = Object.new.tap { |p| p.define_singleton_method(:with) { |&blk| blk.call(conn) } }
+      client  = BugBunny::Client.new(pool: pool)
+
+      allow_any_instance_of(BugBunny::Producer).to receive(:rpc)
+        .and_raise(BugBunny::RequestTimeout.new('timeout'))
+
+      expect { client.request('foo', method: :get, exchange: 'x', exchange_type: 'direct') }
+        .to raise_error(BugBunny::RequestTimeout)
+    end
+  end
+
+  describe 'Producer#confirmed — rescue limitado a Bunny::Exception' do
+    it 'no traga errores genéricos de Ruby (NoMethodError) como CommunicationError' do
+      producer = BugBunny::Producer.new(instance_double(BugBunny::Session))
+      allow(producer).to receive(:setup_return_listener).and_return(nil)
+      allow(producer).to receive(:teardown_return_listener)
+      allow(producer).to receive(:publish_message).and_raise(NoMethodError.new('bug interno'))
+
+      request = BugBunny::Request.new('evt').tap do |r|
+        r.exchange = 'x'
+        r.exchange_type = 'direct'
+        r.delivery_mode = :confirmed
+      end
+
+      expect { producer.confirmed(request) }.to raise_error(NoMethodError, 'bug interno')
+    end
+
+    it 'envuelve Bunny::Exception como CommunicationError' do
+      producer = BugBunny::Producer.new(instance_double(BugBunny::Session))
+      allow(producer).to receive(:setup_return_listener).and_return(nil)
+      allow(producer).to receive(:teardown_return_listener)
+      allow(producer).to receive(:publish_message)
+        .and_raise(Bunny::ChannelAlreadyClosed.new('closed', double(id: 1)))
+
+      request = BugBunny::Request.new('evt').tap do |r|
+        r.exchange = 'x'
+        r.exchange_type = 'direct'
+        r.delivery_mode = :confirmed
+      end
+
+      err = capture_error { producer.confirmed(request) }
+      expect(err).to be_a(BugBunny::CommunicationError)
+      expect(err.message).to match(/Publisher confirms failed/)
+      expect(err.cause).to be_a(Bunny::ChannelAlreadyClosed)
+    end
+  end
+
+  def capture_error
+    yield
+    nil
+  rescue StandardError => e
+    e
+  end
+end

data/spec/unit/producer_spec.rb

@@ -377,13 +377,21 @@ RSpec.describe BugBunny::Producer do
       expect { confirmed_producer.confirmed(req) }.to raise_error(BugBunny::RequestTimeout, /Timeout/)
     end
 
-    it 'envuelve errores del canal como BugBunny::CommunicationError' do
-      allow(mock_channel).to receive(:wait_for_confirms).and_raise(StandardError, 'boom')
+    it 'envuelve Bunny::Exception del canal como BugBunny::CommunicationError' do
+      allow(mock_channel).to receive(:wait_for_confirms)
+        .and_raise(Bunny::ChannelAlreadyClosed.new('boom', double(id: 1)))
 
       expect { confirmed_producer.confirmed(build_request) }
         .to raise_error(BugBunny::CommunicationError, /boom/)
     end
 
+    it 'no traga errores genéricos de Ruby (rescue es Bunny::Exception, no StandardError)' do
+      allow(mock_channel).to receive(:wait_for_confirms).and_raise(NoMethodError, 'bug interno')
+
+      expect { confirmed_producer.confirmed(build_request) }
+        .to raise_error(NoMethodError, 'bug interno')
+    end
+
     it 'propaga BugBunny::Error sin envolver' do
       allow(fake_exchange).to receive(:publish).and_raise(BugBunny::CommunicationError, 'chan dead')
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 4.17.1
+  version: 4.18.0
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-19 00:00:00.000000000 Z
+date: 2026-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -283,6 +283,7 @@ files:
 - spec/support/bunny_mocks.rb
 - spec/support/integration_helper.rb
 - spec/unit/client_session_pool_spec.rb
+- spec/unit/communication_error_wrapping_spec.rb
 - spec/unit/configuration_spec.rb
 - spec/unit/consumer_middleware_spec.rb
 - spec/unit/consumer_spec.rb
@@ -306,7 +307,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/v4.17.1/skill
+  documentation_uri: https://github.com/gedera/bug_bunny/blob/v4.18.0/skill
 post_install_message:
 rdoc_options: []
 require_paths: