bug_bunny 4.9.1 → 4.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c70dd01d8d666fe56dbb95bc925ee431133cc0c342dc113a0775a4dddd4ce135
-  data.tar.gz: 2917d1105969a8173a8b9f70944d9b5839122a56185a5334db0e1c3a04594d2c
+  metadata.gz: 1e1a5c8c069bdf7634c57b1df16aa226d5abc8fd6e864596d273431a680a1b55
+  data.tar.gz: 49b7cf39e53fe8c3f3b90331cfc4f171c8769264356ba1c1d4a767bf27b868ee
 SHA512:
-  metadata.gz: 241b7e0e684aa866d98940a2a3bc587ed13cf1da65c5708ff983c439078c40d823f13cac54ee8bf6d735dda138050c598c8cbf06759605523b8b2207de0e8e4d
-  data.tar.gz: 0b4f509d46dbe3ebd43bf8421bd9938bd2aa5d68ca23e639c3c1d232d5ad9d41b55cec0a4a0096cf8481e46c5d06163ce959d0f0167636d9084bf5d8aa3c9ba2
+  metadata.gz: '082acc0c03183a7d077381563ab9da50657e7468006334b5cfc2d00c8442d603285d38d0f557d67793c833fd6c4d5133c82b3cbbe5048f7f89721c19082971b9'
+  data.tar.gz: 9ee3d5a73a1e339d13241093bedfc9dfe212e2a77fb655f3fe21f1378b02d5e10c86417e12fe637eaa1f9591be3ae1e7c2a72d6ed3dac5ee3007f05d1ee7159f

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [4.10.1] - 2026-04-08
+
+### Correcciones
+- Corregir route matching 404: el path del cliente ahora se normaliza antes de pasarlo a `RouteSet#recognize`. Antes, `URI.parse("http://dummy/#{path}")` prependead un `/` extra al path, causando que rutas existentes no hicieran match. Ahora se usa `path.gsub(%r{^/|/$}, '')` antes del recognize. — @Gabriel
+
 ## [4.9.1] - 2026-04-06
 
 ### Correcciones

data/lib/bug_bunny/consumer.rb

@@ -176,23 +176,25 @@ module BugBunny
 
       safe_log(:info, 'consumer.message_received', method: http_method, path: path,
                                                    routing_key: delivery_info.routing_key, **otel_fields)
-      safe_log(:debug, 'consumer.message_received_body', body: body.truncate(200))
+      safe_log(:info, 'consumer.message_received_body', body: body&.truncate(500), body_size: body&.size || 0)
 
       # ===================================================================
       # 3. Ruteo Declarativo
       # ===================================================================
-      uri = URI.parse("http://dummy/#{path}")
+      normalized_path = path.gsub(%r{^/|/$}, '')
+
+      uri = URI.parse("http://dummy/#{normalized_path}")
 
       # Extraemos query params (ej. /nodes?status=active)
       query_params = uri.query ? Rack::Utils.parse_nested_query(uri.query) : {}
       query_params = query_params.with_indifferent_access if defined?(ActiveSupport::HashWithIndifferentAccess)
 
       # Le preguntamos al motor de rutas global quién debe manejar esto
-      route_info = BugBunny.routes.recognize(http_method, uri.path)
+      route_info = BugBunny.routes.recognize(http_method, normalized_path)
 
       if route_info.nil?
-        safe_log(:warn, 'consumer.route_not_found', method: http_method, path: uri.path)
-        handle_fatal_error(properties, 404, 'Not Found', "No route matches [#{http_method}] \"/#{uri.path}\"")
+        safe_log(:warn, 'consumer.route_not_found', method: http_method, path: normalized_path)
+        handle_fatal_error(properties, 404, 'Not Found', "No route matches [#{http_method}] \"#{normalized_path}\"")
         session.channel.reject(delivery_info.delivery_tag, false)
         return
       end
@@ -256,7 +258,7 @@ module BugBunny
     rescue StandardError => e
       safe_log(:error, 'consumer.execution_error', duration_s: duration_s(start_time), **exception_metadata(e))
       safe_log(:debug, 'consumer.execution_error_backtrace', backtrace: e.backtrace.first(5).join(' | '))
-      handle_fatal_error(properties, 500, 'Internal Server Error', e.message)
+      handle_fatal_error(properties, 500, 'Internal Server Error', e.message, e)
       session.channel.reject(delivery_info.delivery_tag, false)
     end
 
@@ -267,7 +269,12 @@ module BugBunny
     # @param correlation_id [String] ID para correlacionar la respuesta con la petición original.
     # @return [void]
     def reply(payload, reply_to, correlation_id)
-      safe_log(:debug, 'consumer.rpc_reply', reply_to: reply_to, messaging_message_id: correlation_id)
+      safe_log(:info, 'consumer.rpc_reply',
+               reply_to: reply_to,
+               messaging_message_id: correlation_id,
+               response_status: payload[:status],
+               response_body: payload[:body]&.to_json&.truncate(500),
+               response_body_size: payload[:body]&.to_json&.size || 0)
       otel_headers = BugBunny::OTel.messaging_headers(
         operation: 'publish',
         destination: '',
@@ -287,14 +294,20 @@ module BugBunny
     # Maneja errores fatales asegurando que el cliente reciba una respuesta.
     # Evita que el cliente RPC se quede esperando hasta el timeout.
     #
+    # @param properties [Bunny::MessageProperties] Headers y propiedades AMQP.
+    # @param status [Integer] Código de estado HTTP.
+    # @param error_title [String] Título del error.
+    # @param detail [String] Detalle del error.
+    # @param exception [StandardError, nil] Excepción original (para status 500).
     # @api private
-    def handle_fatal_error(properties, status, error_title, detail)
+    def handle_fatal_error(properties, status, error_title, detail, exception = nil)
       return unless properties.reply_to
 
-      error_payload = {
-        status: status,
-        body: { error: error_title, detail: detail }
-      }
+      body = { error: error_title, detail: detail }
+
+      body[:bug_bunny_exception] = BugBunny::RemoteError.serialize(exception) if status == 500 && exception
+
+      error_payload = { status: status, body: body }
       reply(error_payload, properties.reply_to, properties.correlation_id)
     end
 

data/lib/bug_bunny/controller.rb

@@ -224,7 +224,12 @@ module BugBunny
       {
         status: 500,
         headers: response_headers,
-        body: { error: 'Internal Server Error', detail: exception.message, type: exception.class.name }
+        body: {
+          error: 'Internal Server Error',
+          detail: exception.message,
+          type: exception.class.name,
+          bug_bunny_exception: BugBunny::RemoteError.serialize(exception)
+        }
       }
     end
 

data/lib/bug_bunny/middleware/raise_error.rb

@@ -50,6 +50,14 @@ module BugBunny
           # Pasamos el body crudo; UnprocessableEntity lo procesará en exception.rb
           raise BugBunny::UnprocessableEntity, body
         when 500..599
+          if body.is_a?(Hash) && body['bug_bunny_exception']
+            exception_data = body['bug_bunny_exception']
+            raise BugBunny::RemoteError.new(
+              exception_data['class'],
+              exception_data['message'],
+              exception_data['backtrace'] || []
+            )
+          end
           raise BugBunny::InternalServerError, format_error_message(body)
         else
           handle_unknown_error(status, body)

data/lib/bug_bunny/producer.rb

@@ -89,7 +89,9 @@ module BugBunny
         BugBunny.configuration.on_rpc_reply&.call(result[:headers])
 
         safe_log(:debug, 'producer.rpc_response_received',
-                 messaging_system: 'rabbitmq', messaging_operation: 'receive', messaging_message_id: cid)
+                 messaging_system: 'rabbitmq', messaging_operation: 'receive', messaging_message_id: cid,
+                 response_body: result[:body]&.truncate(500),
+                 response_headers: result[:headers]&.to_json&.truncate(300))
 
         parse_response(result[:body])
       ensure
@@ -125,7 +127,12 @@ module BugBunny
       safe_log(:info, 'producer.publish', method: verb, path: target, **otel_fields)
       safe_log(:debug, 'producer.publish_detail', messaging_destination_name: request.exchange,
                                                   exchange_opts: final_x_opts)
-      safe_log(:debug, 'producer.publish_payload', payload: payload.truncate(300)) if payload.is_a?(String)
+      return unless payload.is_a?(String)
+
+      safe_log(:info, 'producer.publish_payload',
+               payload: payload.truncate(500),
+               payload_class: payload.class.name,
+               body_size: request.body.nil? ? 0 : request.body.size)
     end
 
     # Serializa el mensaje para su transporte.

data/lib/bug_bunny/remote_error.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module BugBunny
+  # Error 500 especial que propagationa información de una excepción remota.
+  #
+  # Cuando un controller levanta una excepción no manejada en el worker, esta clase
+  # permite al llamador RPC acceder a:
+  # - La clase original de la excepción (ej: ActiveRecord::RecordNotFound)
+  # - El mensaje original
+  # - El backtrace completo para debugging
+  #
+  # Mantiene compatibilidad hacia atrás: si la respuesta no contiene
+  # bug_bunny_exception, se comporta como un InternalServerError común.
+  class RemoteError < ServerError
+    # @return [String] La clase de la excepción remota (ej: 'ActiveRecord::RecordNotFound').
+    attr_reader :original_class
+
+    # @return [String] El mensaje original de la excepción.
+    attr_reader :original_message
+
+    # @return [Array<String>] El backtrace original de la excepción.
+    attr_reader :original_backtrace
+
+    # Serializa una excepción para transmitirse como parte de la respuesta.
+    #
+    # @param exception [StandardError] La excepción a serializar.
+    # @param max_lines [Integer] Máximo de líneas del backtrace (default 25).
+    # @return [Hash] Estructura con class, message y backtrace.
+    def self.serialize(exception, max_lines: 25)
+      {
+        class: exception.class.name,
+        message: exception.message,
+        backtrace: exception.backtrace&.first(max_lines) || []
+      }
+    end
+
+    # Inicializa la excepción remota propagada desde el worker.
+    #
+    # @param original_class [String] Nombre completo de la clase de la excepción.
+    # @param message [String] Mensaje de la excepción.
+    # @param backtrace [Array<String>] Stack trace completo.
+    def initialize(original_class, message, backtrace)
+      @original_class = original_class
+      @original_message = message
+      @original_backtrace = backtrace || []
+      super(message)
+      set_backtrace(backtrace || [])
+    end
+
+    # @return [String] Representación legible de la excepción.
+    def to_s
+      "#{self.class.name}(#{original_class}): #{message}"
+    end
+  end
+end

data/lib/bug_bunny/resource.rb

@@ -401,6 +401,17 @@ module BugBunny
       attributes['id'] || @extra_attributes['id'] || @extra_attributes['ID'] || @extra_attributes['Id'] || @extra_attributes['_id']
     end
 
+    # Representación legible del recurso.
+    # Muestra solo ID y atributos principales, sin detalles de infraestructura.
+    #
+    # @return [String]
+    def inspect
+      infra_keys = %w[routing_key exchange exchange_type exchange_options queue_options _id]
+      attrs = @extra_attributes.merge(attributes).reject { |k, _| infra_keys.include?(k) || k == 'id' }
+      attr_str = attrs.first(5).map { |k, v| "#{k}=#{v.inspect}" }.join(' ')
+      "#<#{self.class.name} id=#{id.inspect} persisted=#{@persisted}#{" #{attr_str}" unless attr_str.empty?}>"
+    end
+
     def id=(value)
       if self.class.attribute_names.include?('id')
         super
@@ -461,6 +472,7 @@ module BugBunny
     # @return [Boolean]
     def destroy
       return false unless persisted?
+      return false unless id
 
       run_callbacks(:destroy) do
         path = "#{self.class.resource_name}/#{id}"

data/lib/bug_bunny/version.rb

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

data/lib/bug_bunny.rb

@@ -4,6 +4,7 @@ require 'bunny'
 require 'logger'
 require_relative 'bug_bunny/version'
 require_relative 'bug_bunny/exception'
+require_relative 'bug_bunny/remote_error'
 require_relative 'bug_bunny/configuration'
 require_relative 'bug_bunny/observability'
 require_relative 'bug_bunny/otel'

data/skill/SKILL.md

@@ -230,6 +230,10 @@ No registrar consumer middlewares durante la ejecución de `call()`. El stack to
 **Causa:** El mensaje intenta ejecutar un controlador que no hereda de `BugBunny::Controller`.
 **Resolución:** Verificar la jerarquía de controladores y que `config.controller_namespace` coincida.
 
+### BugBunny::RouteNotFoundError (404)
+**Causa:** El path del mensaje no coincide con ninguna ruta registrada. El path debe estar normalizado (sin slashes iniciales/trailing).
+**Resolución:** Verificar que el cliente envíe el path sin leading/trailing slashes (ej: `users/42`, no `/users/42/`).
+
 ### BugBunny::UnprocessableEntity (422)
 **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`.

data/skill/references/consumer.md

@@ -21,13 +21,14 @@ consumer = BugBunny::Consumer.subscribe(
 2. Extrae campos **OTel messaging** del mensaje para logs estructurados (sin mutar headers).
 3. Valida que el mensaje tenga header `type` (path).
 4. Parsea el método HTTP de headers (`x-http-method` o `method`).
-5. Emite log `consumer.message_received` con campos OTel (`messaging_operation: 'process'`).
-6. Reconoce la ruta con `BugBunny.routes.recognize(method, path)`.
-7. Resuelve el controlador validando herencia de `BugBunny::Controller`.
-8. Ejecuta consumer middlewares → controller callbacks → acción.
-9. Responde via `reply_to` si está presente (RPC), inyectando campos OTel (`messaging_operation: 'publish'`).
-10. Emite log `consumer.message_processed` con campos OTel y duraciones.
-11. Hace `ack` del mensaje. En caso de error, `reject`.
+5. **Normaliza el path**: remueve slashes iniciales/trailing (`path.gsub(%r{^/|/$}, '')`).
+6. Emite log `consumer.message_received` con campos OTel (`messaging_operation: 'process'`).
+7. Reconoce la ruta con `BugBunny.routes.recognize(method, normalized_path)`.
+8. Resuelve el controlador validando herencia de `BugBunny::Controller`.
+9. Ejecuta consumer middlewares → controller callbacks → acción.
+10. Responde via `reply_to` si está presente (RPC), inyectando campos OTel (`messaging_operation: 'publish'`).
+11. Emite log `consumer.message_processed` con campos OTel y duraciones.
+12. Hace `ack` del mensaje. En caso de error, `reject`.
 
 ## Observability: OTel Fields
 

data/skills.lock

@@ -1,5 +1,5 @@
 ---
-synced_at: '2026-04-06 14:08:54'
+synced_at: '2026-04-08 09:13:30'
 skills:
 - name: agent-review
   scope: local

data/spec/integration/resource_spec.rb

@@ -110,4 +110,48 @@ RSpec.describe BugBunny::Resource, :integration do
       end
     end
   end
+
+  describe '#inspect' do
+    let(:node) { SpecNode.new(id: '123', name: 'test-node', status: 'active', ip: '192.168.1.1', port: 8080) }
+
+    it 'muestra id y persisted' do
+      expect(node.inspect).to include('id="123"')
+      expect(node.inspect).to include('persisted=false')
+    end
+
+    it 'muestra atributos principales sin detalles de infraestructura' do
+      result = node.inspect
+
+      expect(result).to include('name="test-node"')
+      expect(result).to include('status="active"')
+      expect(result).to include('ip="192.168.1.1"')
+      expect(result).to include('port=8080')
+      expect(result).not_to include('routing_key')
+      expect(result).not_to include('exchange')
+    end
+
+    it 'filtra atributos de infraestructura cuando están presentes' do
+      node.routing_key = 'radius_1'
+      node.exchange = 'test_exchange'
+      node.exchange_type = 'topic'
+      node.exchange_options = { durable: true }
+      node.persisted = true
+
+      result = node.inspect
+
+      expect(result).not_to include('routing_key')
+      expect(result).not_to include('exchange')
+      expect(result).not_to include('exchange_type')
+      expect(result).not_to include('exchange_options')
+      expect(result).to include('persisted=true')
+    end
+
+    it 'limita a 5 atributos principales' do
+      node = SpecNode.new(id: '1', a: '1', b: '2', c: '3', d: '4', e: '5', f: '6')
+
+      result = node.inspect
+
+      expect(result.scan('=').length).to be <= 7 # id + persisted + max 5 attrs
+    end
+  end
 end

data/spec/unit/route_spec.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BugBunny::Routing::Route do
+  describe '#match? and #extract_params — path normalization' do
+    let(:route) { described_class.new('GET', 'services/otaigccd59q0k7kxb1h193go2/restart', to: 'services#restart') }
+
+    it 'matches path without leading slash' do
+      expect(route.match?('GET', 'services/otaigccd59q0k7kxb1h193go2/restart')).to be true
+    end
+
+    it 'matches path with leading slash' do
+      expect(route.match?('GET', '/services/otaigccd59q0k7kxb1h193go2/restart')).to be true
+    end
+
+    it 'matches path with trailing slash' do
+      expect(route.match?('GET', 'services/otaigccd59q0k7kxb1h193go2/restart/')).to be true
+    end
+
+    it 'matches path with leading and trailing slash' do
+      expect(route.match?('GET', '/services/otaigccd59q0k7kxb1h193go2/restart/')).to be true
+    end
+
+    it 'extracts params from path without slash' do
+      params = route.extract_params('services/otaigccd59q0k7kxb1h193go2/restart')
+      expect(params).to eq({})
+    end
+
+    it 'extracts params from path with slash' do
+      params = route.extract_params('/services/otaigccd59q0k7kxb1h193go2/restart')
+      expect(params).to eq({})
+    end
+
+    context 'route with dynamic segment' do
+      let(:route_with_id) { described_class.new('GET', 'nodes/:id', to: 'nodes#show') }
+
+      it 'extracts params from path without slash' do
+        params = route_with_id.extract_params('nodes/123')
+        expect(params).to eq({ 'id' => '123' })
+      end
+
+      it 'extracts params from path with slash' do
+        params = route_with_id.extract_params('/nodes/123')
+        expect(params).to eq({ 'id' => '123' })
+      end
+    end
+
+    context 'route defined with leading slash' do
+      let(:route_with_leading_slash) do
+        described_class.new('GET', '/services/otaigccd59q0k7kxb1h193go2/restart', to: 'services#restart')
+      end
+
+      it 'matches path without slash' do
+        expect(route_with_leading_slash.match?('GET', 'services/otaigccd59q0k7kxb1h193go2/restart')).to be true
+      end
+
+      it 'matches path with slash' do
+        expect(route_with_leading_slash.match?('GET', '/services/otaigccd59q0k7kxb1h193go2/restart')).to be true
+      end
+    end
+  end
+
+  describe 'RouteSet#recognize path normalization' do
+    let(:route_set) { BugBunny::Routing::RouteSet.new }
+
+    before do
+      route_set.draw do
+        get 'services/otaigccd59q0k7kxb1h193go2/restart', to: 'services#restart'
+      end
+    end
+
+    it 'recognizes path without slash' do
+      result = route_set.recognize('GET', 'services/otaigccd59q0k7kxb1h193go2/restart')
+      expect(result).not_to be_nil
+      expect(result[:controller]).to eq('services')
+      expect(result[:action]).to eq('restart')
+    end
+
+    it 'recognizes path with leading slash' do
+      result = route_set.recognize('GET', '/services/otaigccd59q0k7kxb1h193go2/restart')
+      expect(result).not_to be_nil
+      expect(result[:controller]).to eq('services')
+      expect(result[:action]).to eq('restart')
+    end
+
+    it 'returns nil for non-matching path' do
+      result = route_set.recognize('GET', 'services/nonexistent')
+      expect(result).to be_nil
+    end
+  end
+
+  describe 'Consumer path handling — URI parsing edge case' do
+    let(:channel) { BunnyMocks::FakeChannel.new(true) }
+    let(:connection) { BunnyMocks::FakeConnection.new(true, channel) }
+
+    let(:mock_channel) do
+      ch = double('channel')
+      allow(ch).to receive(:reject)
+      allow(ch).to receive(:ack)
+      allow(ch).to receive(:open?).and_return(true)
+      default_ex = double('default_exchange')
+      allow(default_ex).to receive(:publish)
+      allow(ch).to receive(:default_exchange).and_return(default_ex)
+      ch
+    end
+
+    let(:mock_session) do
+      s = instance_double(BugBunny::Session)
+      allow(s).to receive(:exchange).and_return(double('exchange'))
+      allow(s).to receive(:queue).and_return(double('queue'))
+      allow(s).to receive(:close)
+      allow(s).to receive(:channel).and_return(mock_channel)
+      s
+    end
+
+    let(:test_consumer) do
+      c = BugBunny::Consumer.new(connection)
+      c.instance_variable_set(:@session, mock_session)
+      c
+    end
+
+    let(:delivery_info) do
+      double('delivery_info',
+             exchange: 'events_x',
+             routing_key: 'users.created',
+             delivery_tag: 'delivery-tag-1',
+             redelivered?: false)
+    end
+
+    let(:properties) do
+      double('properties',
+             type: 'services/otaigccd59q0k7kxb1h193go2/restart',
+             headers: { 'x-http-method' => 'GET' },
+             correlation_id: 'corr-abc-123',
+             reply_to: nil,
+             content_type: 'application/json')
+    end
+
+    let(:logged_events) { [] }
+
+    before do
+      allow(test_consumer).to receive(:safe_log) do |level, event, **kwargs|
+        logged_events << { level: level, event: event, kwargs: kwargs }
+      end
+      allow(test_consumer).to receive(:handle_fatal_error)
+    end
+
+    it 'logs route_not_found with normalized path (without extra slash)' do
+      allow(BugBunny.routes).to receive(:recognize).and_return(nil)
+
+      test_consumer.send(:process_message, delivery_info, properties, '{}')
+
+      route_not_found_event = logged_events.find { |e| e[:event] == 'consumer.route_not_found' }
+      expect(route_not_found_event).not_to be_nil
+      expect(route_not_found_event[:kwargs][:path]).to eq('services/otaigccd59q0k7kxb1h193go2/restart')
+    end
+
+    context 'when properties.type has leading slash' do
+      let(:properties) do
+        double('properties',
+               type: '/services/otaigccd59q0k7kxb1h193go2/restart',
+               headers: { 'x-http-method' => 'GET' },
+               correlation_id: 'corr-abc-123',
+               reply_to: nil,
+               content_type: 'application/json')
+      end
+
+      it 'logs route_not_found with normalized path (stripped leading slash)' do
+        allow(BugBunny.routes).to receive(:recognize).and_return(nil)
+
+        test_consumer.send(:process_message, delivery_info, properties, '{}')
+
+        route_not_found_event = logged_events.find { |e| e[:event] == 'consumer.route_not_found' }
+        expect(route_not_found_event).not_to be_nil
+        expect(route_not_found_event[:kwargs][:path]).to eq('services/otaigccd59q0k7kxb1h193go2/restart')
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 4.9.1
+  version: 4.10.1
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-07 00:00:00.000000000 Z
+date: 2026-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -249,6 +249,7 @@ files:
 - lib/bug_bunny/otel.rb
 - lib/bug_bunny/producer.rb
 - lib/bug_bunny/railtie.rb
+- lib/bug_bunny/remote_error.rb
 - lib/bug_bunny/request.rb
 - lib/bug_bunny/resource.rb
 - lib/bug_bunny/routing/route.rb
@@ -289,6 +290,7 @@ files:
 - spec/unit/producer_spec.rb
 - spec/unit/request_spec.rb
 - spec/unit/resource_attributes_spec.rb
+- spec/unit/route_spec.rb
 - spec/unit/session_spec.rb
 - test/integration/infrastructure_test.rb
 - test/integration/manual_client_test.rb
@@ -300,7 +302,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.9.1/skill
+  documentation_uri: https://github.com/gedera/bug_bunny/blob/v4.10.1/skill
 post_install_message:
 rdoc_options: []
 require_paths: