bug_bunny 4.10.1 → 4.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1a5c8c069bdf7634c57b1df16aa226d5abc8fd6e864596d273431a680a1b55
-  data.tar.gz: 49b7cf39e53fe8c3f3b90331cfc4f171c8769264356ba1c1d4a767bf27b868ee
+  metadata.gz: 31a6f6e9b83b1a82216f344a101ca0a99daebb5fd9e44bf5abc9c9e9753f4011
+  data.tar.gz: f101254aad9d8bbd66a359438a1efe970acd58e4b853841bcda72966c2472c8c
 SHA512:
-  metadata.gz: '082acc0c03183a7d077381563ab9da50657e7468006334b5cfc2d00c8442d603285d38d0f557d67793c833fd6c4d5133c82b3cbbe5048f7f89721c19082971b9'
-  data.tar.gz: 9ee3d5a73a1e339d13241093bedfc9dfe212e2a77fb655f3fe21f1378b02d5e10c86417e12fe637eaa1f9591be3ae1e7c2a72d6ed3dac5ee3007f05d1ee7159f
+  metadata.gz: 6b8a42f884ae9c8075dab9e4052658a5c0828cae904800fe222fd058cdaf3cd1307bba6478ca7824e273a517484d71da0416fd3b7c38bb08a9a0845e39dacb90
+  data.tar.gz: 6de916fae62566f01142b557b6e6c4ed4cf44d58298d9ff3c174e8d38b4422238487dacd29f273d7b3ea356d30f8c08a5c5a872f9ed08f6cacb8a540511a933a

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [4.10.2] - 2026-04-08
+
+### Correcciones
+- **RemoteError#to_s recursión infinita:** Corregir `SystemStackError` al invocar `to_s` en `BugBunny::RemoteError` en IRB. Antes, `to_s` llamaba a `message`, que en Ruby delega a `to_s`, generando recursión infinita. Ahora usa `super` para invocar `Exception#to_s` directamente. — @Gabriel
+
 ## [4.10.1] - 2026-04-08
 
 ### Correcciones

data/README.md

@@ -228,6 +228,57 @@ Las claves sensibles (`password`, `token`, `secret`, `api_key`, `authorization`,
 
 ---
 
+## Error Handling
+
+BugBunny maps RabbitMQ responses to a semantic exception hierarchy, similar to how HTTP clients handle status codes.
+
+### Exception Hierarchy
+
+```
+BugBunny::Error
+├── ClientError (4xx)
+│   ├── BadRequest (400)
+│   ├── NotFound (404)
+│   ├── NotAcceptable (406)
+│   ├── RequestTimeout (408)
+│   ├── Conflict (409)
+│   └── UnprocessableEntity (422)
+└── ServerError (5xx)
+    ├── InternalServerError (500+)
+    └── RemoteError (500)
+```
+
+### Remote Exception Propagation
+
+When a controller raises an unhandled exception, BugBunny serializes it and sends it back to the caller as a 500 response. The client-side middleware reconstructs it as a `BugBunny::RemoteError` with full access to the original exception details:
+
+```ruby
+begin
+  node = RemoteNode.find('node-123')
+rescue BugBunny::RemoteError => e
+  e.original_class     # => "TypeError"
+  e.original_message   # => "nil can't be coerced into Integer"
+  e.original_backtrace # => Array<String> from the remote service
+rescue BugBunny::NotFound
+  # Resource doesn't exist
+rescue BugBunny::RequestTimeout
+  # Consumer didn't respond in time
+end
+```
+
+### Validation Errors
+
+`Resource#save` returns `false` on validation failure and loads remote errors into the model:
+
+```ruby
+order = RemoteOrder.new(total: -1)
+unless order.save
+  order.errors.full_messages # => ["total must be greater than 0"]
+end
+```
+
+---
+
 ## Documentation
 
 - [Concepts](docs/concepts.md) — What BugBunny is, AMQP in 5 minutes, RPC vs fire-and-forget

data/lib/bug_bunny/remote_error.rb

@@ -49,7 +49,7 @@ module BugBunny
 
     # @return [String] Representación legible de la excepción.
     def to_s
-      "#{self.class.name}(#{original_class}): #{message}"
+      "#{self.class.name}(#{original_class}): #{super}"
     end
   end
 end

data/lib/bug_bunny/version.rb

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

data/lib/bug_bunny.rb

@@ -83,7 +83,12 @@ module BugBunny
   # @raise [Bunny::TCPConnectionFailed] Si no se puede conectar al servidor.
   def self.create_connection(**options)
     conn_options = merge_connection_options(options)
-    Bunny.new(conn_options).tap(&:start)
+    Bunny.new(conn_options).tap do |conn|
+      conn.after_recovery_completed do
+        safe_log(:info, 'bug_bunny.connection_recovered', host: conn_options[:host])
+      end
+      conn.start
+    end
   end
 
   # Cierra la conexión global si existe.

data/skill/SKILL.md

@@ -238,6 +238,10 @@ No registrar consumer middlewares durante la ejecución de `call()`. El stack to
 **Causa:** Fallo de validación en el servicio remoto.
 **Resolución:** `resource.save` devuelve `false`. Acceder a `resource.errors` o `rescue` con `e.error_messages`.
 
+### BugBunny::RemoteError (500)
+**Causa:** Excepción no manejada en el controller remoto. Se serializa y propaga al cliente RPC con clase, mensaje y backtrace originales.
+**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.

data/skill/references/errores.md

@@ -16,7 +16,8 @@ StandardError
     │   ├── BugBunny::Conflict (409)
     │   └── BugBunny::UnprocessableEntity (422)
     └── BugBunny::ServerError (5xx)
-        └── BugBunny::InternalServerError (500+)
+        ├── BugBunny::InternalServerError (500+)
+        └── BugBunny::RemoteError (500)
 ```
 
 ## Errores de Infraestructura
@@ -83,6 +84,39 @@ end
 **Causa:** Cualquier error de servidor no mapeado a InternalServerError.
 **Resolución:** Similar a InternalServerError.
 
+### BugBunny::RemoteError (500)
+**Causa:** Excepción no manejada en el controller remoto. El error se serializa y propaga al cliente RPC.
+
+**Flujo completo:**
+1. El controller remoto lanza una excepción (ej: `TypeError`).
+2. `BugBunny::Controller#handle_exception` la captura y serializa con `RemoteError.serialize(exception)` → `{ class:, message:, backtrace: }` (máx 25 líneas).
+3. El consumer responde con status 500 y el campo `bug_bunny_exception` en el body.
+4. El middleware `RaiseError` del cliente detecta `bug_bunny_exception`, reconstituye un `BugBunny::RemoteError` y lo lanza localmente.
+
+**Acceso a detalles:**
+```ruby
+# Con Client directo
+begin
+  client.request('users/42', method: :get)
+rescue BugBunny::RemoteError => e
+  e.original_class     # => "TypeError"
+  e.original_message   # => "nil can't be coerced into Integer"
+  e.original_backtrace # => Array<String> (backtrace del servicio remoto)
+  e.to_s               # => "BugBunny::RemoteError(TypeError): nil can't be coerced into Integer"
+end
+
+# Con Resource ORM
+begin
+  RemoteNode.find('node-123')
+rescue BugBunny::RemoteError => e
+  Rails.logger.error("Remote #{e.original_class}: #{e.original_message}")
+end
+```
+
+**Compatibilidad:** Si la respuesta 500 no contiene `bug_bunny_exception` (ej: servicio remoto con versión anterior de BugBunny), se lanza `BugBunny::InternalServerError` en su lugar.
+
+**Herencia:** `RemoteError < ServerError < Error < StandardError`. Se puede capturar con `rescue BugBunny::ServerError` para atrapar tanto `RemoteError` como `InternalServerError`.
+
 ## Formato de Mensajes de Error
 
 El middleware `RaiseError` construye el mensaje así:

data/spec/unit/remote_error_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BugBunny::RemoteError do
+  subject(:error) do
+    described_class.new('TypeError', 'nil can\'t be coerced into Integer', [
+                          "/app/controllers/services_controller.rb:5:in 'Integer#*'",
+                          "/app/controllers/services_controller.rb:5:in 'ServicesController#index'"
+                        ])
+  end
+
+  describe '#to_s' do
+    it 'does not cause infinite recursion (message -> to_s -> message)' do
+      expect(error.to_s).to eq("BugBunny::RemoteError(TypeError): nil can't be coerced into Integer")
+    end
+  end
+
+  describe '#message' do
+    it 'returns the formatted string without stack overflow' do
+      expect(error.message).to eq("BugBunny::RemoteError(TypeError): nil can't be coerced into Integer")
+    end
+  end
+
+  describe '#inspect' do
+    it 'is renderable by IRB without raising' do
+      expect { error.inspect }.not_to raise_error
+    end
+  end
+
+  describe '.serialize' do
+    it 'serializes an exception with class, message and backtrace' do
+      exception = TypeError.new('test error')
+      exception.set_backtrace(%w[line1 line2])
+
+      result = described_class.serialize(exception)
+
+      expect(result).to eq(class: 'TypeError', message: 'test error', backtrace: %w[line1 line2])
+    end
+
+    it 'truncates backtrace to max_lines' do
+      exception = TypeError.new('test')
+      exception.set_backtrace(Array.new(30) { |i| "line#{i}" })
+
+      result = described_class.serialize(exception, max_lines: 5)
+
+      expect(result[:backtrace].size).to eq(5)
+    end
+  end
+
+  describe 'attributes' do
+    it 'exposes the original exception class' do
+      expect(error.original_class).to eq('TypeError')
+    end
+
+    it 'exposes the original message' do
+      expect(error.original_message).to eq("nil can't be coerced into Integer")
+    end
+
+    it 'exposes the original backtrace' do
+      expect(error.original_backtrace.size).to eq(2)
+    end
+
+    it 'sets the Ruby backtrace to the remote backtrace' do
+      expect(error.backtrace).to eq(error.original_backtrace)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 4.10.1
+  version: 4.10.3
 platform: ruby
 authors:
 - gabix
@@ -288,6 +288,7 @@ files:
 - spec/unit/observability_spec.rb
 - spec/unit/otel_spec.rb
 - spec/unit/producer_spec.rb
+- spec/unit/remote_error_spec.rb
 - spec/unit/request_spec.rb
 - spec/unit/resource_attributes_spec.rb
 - spec/unit/route_spec.rb
@@ -302,7 +303,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.10.1/skill
+  documentation_uri: https://github.com/gedera/bug_bunny/blob/v4.10.3/skill
 post_install_message:
 rdoc_options: []
 require_paths: