bug_bunny 4.8.1 → 4.9.1

data/spec/unit/consumer_spec.rb

@@ -15,6 +15,7 @@ RSpec.describe BugBunny::Consumer do
     allow(session).to receive(:exchange).and_return(double('exchange'))
     allow(session).to receive(:queue).and_return(fake_queue)
     allow(session).to receive(:close)
+    allow(session).to receive(:channel).and_return(channel)
     session
   end
 
@@ -29,6 +30,137 @@ RSpec.describe BugBunny::Consumer do
     consumer.instance_variable_set(:@session, fake_session)
   end
 
+  describe 'OTel messaging semantic conventions en logs' do
+    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(fake_queue)
+      allow(s).to receive(:close)
+      allow(s).to receive(:channel).and_return(mock_channel)
+      s
+    end
+
+    let(:otel_consumer) do
+      c = described_class.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: 'users/show',
+             headers: { 'x-http-method' => 'GET' },
+             correlation_id: 'corr-abc-123',
+             reply_to: 'amq.rabbitmq.reply-to',
+             content_type: 'application/json')
+    end
+
+    let(:logged_events) { [] }
+
+    before do
+      allow(otel_consumer).to receive(:safe_log) do |level, event, **kwargs|
+        logged_events << { level: level, event: event, kwargs: kwargs }
+      end
+      allow(otel_consumer).to receive(:handle_fatal_error)
+    end
+
+    describe '#process_message — log events incluyen campos OTel' do
+      it 'consumer.message_received incluye otel_fields con operation=process' do
+        allow(BugBunny.routes).to receive(:recognize).and_return(
+          { controller: 'user', action: 'show', params: {}, namespace: nil }
+        )
+
+        controller_class = Class.new(BugBunny::Controller) do
+          def show
+            render status: 200, json: { ok: true }
+          end
+        end
+        stub_const('BugBunny::Controllers::UserController', controller_class)
+
+        otel_consumer.send(:process_message, delivery_info, properties, '{}')
+
+        received_event = logged_events.find { |e| e[:event] == 'consumer.message_received' }
+        expect(received_event).not_to be_nil
+        expect(received_event[:kwargs]).to include(
+          messaging_system: 'rabbitmq',
+          messaging_operation: 'process',
+          messaging_destination_name: 'events_x',
+          messaging_routing_key: 'users.created',
+          messaging_message_id: 'corr-abc-123'
+        )
+      end
+
+      it 'consumer.message_processed incluye otel_fields con operation=process' do
+        allow(BugBunny.routes).to receive(:recognize).and_return(
+          { controller: 'user', action: 'show', params: {}, namespace: nil }
+        )
+
+        controller_class = Class.new(BugBunny::Controller) do
+          def show
+            render status: 200, json: { ok: true }
+          end
+        end
+        stub_const('BugBunny::Controllers::UserController', controller_class)
+
+        otel_consumer.send(:process_message, delivery_info, properties, '{}')
+
+        processed_event = logged_events.find { |e| e[:event] == 'consumer.message_processed' }
+        expect(processed_event).not_to be_nil
+        expect(processed_event[:kwargs]).to include(
+          messaging_system: 'rabbitmq',
+          messaging_operation: 'process',
+          messaging_destination_name: 'events_x',
+          messaging_routing_key: 'users.created',
+          messaging_message_id: 'corr-abc-123'
+        )
+      end
+
+      it 'consumer.message_received omite messaging_message_id cuando no hay correlation_id' do
+        properties_no_corr = double('properties',
+                                    type: 'users/show',
+                                    headers: { 'x-http-method' => 'GET' },
+                                    correlation_id: nil,
+                                    reply_to: nil,
+                                    content_type: 'application/json')
+
+        allow(BugBunny.routes).to receive(:recognize).and_return(
+          { controller: 'user', action: 'show', params: {}, namespace: nil }
+        )
+
+        controller_class = Class.new(BugBunny::Controller) do
+          def show
+            render status: 200, json: { ok: true }
+          end
+        end
+        stub_const('BugBunny::Controllers::UserController', controller_class)
+
+        otel_consumer.send(:process_message, delivery_info, properties_no_corr, '{}')
+
+        received_event = logged_events.find { |e| e[:event] == 'consumer.message_received' }
+        expect(received_event[:kwargs]).not_to have_key(:messaging_message_id)
+      end
+    end
+  end
+
   describe '#shutdown' do
     it 'detiene el health timer' do
       timer = instance_double(Concurrent::TimerTask)
@@ -57,10 +189,10 @@ RSpec.describe BugBunny::Consumer do
       consumer.define_singleton_method(:shutdown) { shutdown_called = true }
 
       consumer.subscribe(
-        queue_name:    'q',
+        queue_name: 'q',
         exchange_name: 'x',
-        routing_key:   '#',
-        block:         false
+        routing_key: '#',
+        block: false
       )
 
       expect(shutdown_called).to be(true)
@@ -75,10 +207,10 @@ RSpec.describe BugBunny::Consumer do
 
       expect do
         consumer.subscribe(
-          queue_name:    'q',
+          queue_name: 'q',
           exchange_name: 'x',
-          routing_key:   '#',
-          block:         false
+          routing_key: '#',
+          block: false
         )
       end.to raise_error(RuntimeError)
 

data/spec/unit/otel_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BugBunny::OTel do
+  describe '.messaging_headers' do
+    it 'emite los campos base con messaging.system = rabbitmq' do
+      headers = described_class.messaging_headers(
+        operation: 'publish',
+        destination: 'events_x',
+        routing_key: 'users.created'
+      )
+
+      expect(headers).to include(
+        :messaging_system => 'rabbitmq',
+        :messaging_operation => 'publish',
+        :messaging_destination_name => 'events_x',
+        :messaging_routing_key => 'users.created'
+      )
+    end
+
+    it 'omite messaging.message.id cuando message_id es nil' do
+      headers = described_class.messaging_headers(
+        operation: 'publish',
+        destination: 'x',
+        routing_key: 'rk'
+      )
+
+      expect(headers).not_to have_key(:messaging_message_id)
+    end
+
+    it 'incluye messaging.message.id cuando se provee' do
+      headers = described_class.messaging_headers(
+        operation: 'publish',
+        destination: 'x',
+        routing_key: 'rk',
+        message_id: 'abc-123'
+      )
+
+      expect(headers[:messaging_message_id]).to eq('abc-123')
+    end
+
+    it 'coacciona destination y routing_key nil a string vacío' do
+      headers = described_class.messaging_headers(
+        operation: 'receive',
+        destination: nil,
+        routing_key: nil
+      )
+
+      expect(headers[:messaging_destination_name]).to eq('')
+      expect(headers[:messaging_routing_key]).to eq('')
+    end
+  end
+end

data/spec/unit/producer_spec.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/bunny_mocks'
+
+RSpec.describe BugBunny::Producer do
+  include BunnyMocks
+
+  let(:channel)    { BunnyMocks::FakeChannel.new(true) }
+  let(:connection) { BunnyMocks::FakeConnection.new(true, channel) }
+  let(:session)    { BugBunny::Session.new(connection) }
+  let(:producer)   { described_class.new(session) }
+
+  let(:logged_events) { [] }
+
+  before do
+    allow(producer).to receive(:safe_log) do |level, event, **kwargs|
+      logged_events << { level: level, event: event, kwargs: kwargs }
+    end
+  end
+
+  describe 'OTel messaging semantic conventions en logs' do
+    describe '#fire — log events incluyen campos OTel' do
+      it 'producer.publish incluye otel_fields con operation=publish' do
+        request = BugBunny::Request.new('users')
+        request.exchange = 'users_x'
+        request.method = :post
+        request.body = { name: 'test' }
+
+        fake_exchange = double('exchange')
+        allow(session).to receive(:exchange).and_return(fake_exchange)
+        allow(fake_exchange).to receive(:publish)
+
+        producer.fire(request)
+
+        publish_event = logged_events.find { |e| e[:event] == 'producer.publish' }
+        expect(publish_event).not_to be_nil
+        expect(publish_event[:kwargs]).to include(
+          method: 'POST',
+          path: 'users',
+          messaging_system: 'rabbitmq',
+          messaging_operation: 'publish',
+          messaging_destination_name: 'users_x',
+          messaging_routing_key: 'users'
+        )
+      end
+
+      it 'producer.publish incluye messaging_message_id cuando hay correlation_id' do
+        request = BugBunny::Request.new('users/42')
+        request.exchange = 'users_x'
+        request.correlation_id = 'corr-xyz-789'
+        request.method = :get
+
+        fake_exchange = double('exchange')
+        allow(session).to receive(:exchange).and_return(fake_exchange)
+        allow(fake_exchange).to receive(:publish)
+
+        producer.fire(request)
+
+        publish_event = logged_events.find { |e| e[:event] == 'producer.publish' }
+        expect(publish_event[:kwargs]).to include(
+          messaging_message_id: 'corr-xyz-789'
+        )
+      end
+
+      it 'producer.publish omite messaging_message_id cuando no hay correlation_id' do
+        request = BugBunny::Request.new('users')
+        request.exchange = 'users_x'
+        request.method = :post
+
+        fake_exchange = double('exchange')
+        allow(session).to receive(:exchange).and_return(fake_exchange)
+        allow(fake_exchange).to receive(:publish)
+
+        producer.fire(request)
+
+        publish_event = logged_events.find { |e| e[:event] == 'producer.publish' }
+        expect(publish_event[:kwargs]).not_to have_key(:messaging_message_id)
+      end
+
+      it 'producer.publish_detail incluye messaging_destination_name' do
+        request = BugBunny::Request.new('users')
+        request.exchange = 'events_x'
+        request.method = :post
+
+        fake_exchange = double('exchange')
+        allow(session).to receive(:exchange).and_return(fake_exchange)
+        allow(fake_exchange).to receive(:publish)
+
+        producer.fire(request)
+
+        detail_event = logged_events.find { |e| e[:event] == 'producer.publish_detail' }
+        expect(detail_event).not_to be_nil
+        expect(detail_event[:kwargs]).to include(
+          messaging_destination_name: 'events_x'
+        )
+      end
+    end
+
+    describe '#rpc — log events incluyen campos OTel' do
+      let(:fake_exchange) { double('exchange') }
+      let(:mock_channel) do
+        ch = double('channel')
+        allow(ch).to receive(:publish)
+        allow(ch).to receive(:basic_consume)
+        allow(ch).to receive(:open?).and_return(true)
+        ch
+      end
+
+      let(:mock_session) do
+        s = instance_double(BugBunny::Session)
+        allow(s).to receive(:exchange).and_return(fake_exchange)
+        allow(s).to receive(:channel).and_return(mock_channel)
+        s
+      end
+
+      let(:rpc_producer) { described_class.new(mock_session) }
+
+      before do
+        allow(rpc_producer).to receive(:safe_log) do |level, event, **kwargs|
+          logged_events << { level: level, event: event, kwargs: kwargs }
+        end
+        allow(fake_exchange).to receive(:publish)
+      end
+
+      it 'producer.rpc_waiting incluye messaging_message_id' do
+        request = BugBunny::Request.new('users')
+        request.exchange = 'users_x'
+        request.method = :get
+
+        allow(rpc_producer).to receive(:ensure_reply_listener!)
+
+        ivar = Concurrent::IVar.new
+        allow(Concurrent::IVar).to receive(:new).and_return(ivar)
+        allow(rpc_producer).to receive(:sleep)
+
+        request.correlation_id = 'test-cid'
+
+        rpc_producer.instance_variable_get(:@pending_requests)['test-cid'] = ivar
+
+        thread = Thread.new do
+          sleep 0.05
+          ivar.set({ body: '{"ok":true}', headers: {} })
+        end
+        thread.join
+
+        rpc_producer.rpc(request)
+
+        waiting_event = logged_events.find { |e| e[:event] == 'producer.rpc_waiting' }
+        expect(waiting_event).not_to be_nil
+        expect(waiting_event[:kwargs]).to include(
+          messaging_message_id: 'test-cid',
+          timeout_s: an_instance_of(Integer)
+        )
+      end
+
+      it 'producer.rpc_response_received incluye otel_fields con operation=receive' do
+        request = BugBunny::Request.new('users')
+        request.exchange = 'users_x'
+        request.method = :get
+
+        allow(rpc_producer).to receive(:ensure_reply_listener!)
+
+        ivar = Concurrent::IVar.new
+        allow(Concurrent::IVar).to receive(:new).and_return(ivar)
+        allow(rpc_producer).to receive(:sleep)
+
+        request.correlation_id = 'corr-reply-test'
+
+        rpc_producer.instance_variable_get(:@pending_requests)['corr-reply-test'] = ivar
+
+        thread = Thread.new { ivar.set({ body: '{"ok":true}', headers: {} }) }
+        thread.join(0.1)
+
+        rpc_producer.rpc(request)
+
+        response_event = logged_events.find { |e| e[:event] == 'producer.rpc_response_received' }
+        expect(response_event).not_to be_nil
+        expect(response_event[:kwargs]).to include(
+          messaging_system: 'rabbitmq',
+          messaging_operation: 'receive',
+          messaging_message_id: 'corr-reply-test'
+        )
+      end
+    end
+  end
+end

data/spec/unit/request_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BugBunny::Request do
+  subject(:request) do
+    req = described_class.new('users/42')
+    req.exchange = 'users_x'
+    req.method = :post
+    req
+  end
+
+  describe '#amqp_options' do
+    it 'inyecta los campos OTel con operation=publish como string keys' do
+      headers = request.amqp_options[:headers]
+
+      expect(headers).to include(
+        'messaging_system' => 'rabbitmq',
+        'messaging_operation' => 'publish',
+        'messaging_destination_name' => 'users_x',
+        'messaging_routing_key' => 'users/42'
+      )
+    end
+
+    it 'incluye messaging_message_id cuando hay correlation_id' do
+      request.correlation_id = 'corr-xyz'
+
+      expect(request.amqp_options[:headers]['messaging_message_id']).to eq('corr-xyz')
+    end
+
+    it 'omite messaging_message_id cuando no hay correlation_id' do
+      expect(request.amqp_options[:headers]).not_to have_key('messaging_message_id')
+    end
+
+    it 'preserva x-http-method con el verbo en mayúsculas' do
+      expect(request.amqp_options[:headers]['x-http-method']).to eq('POST')
+    end
+
+    it 'permite a headers del usuario sobrescribir campos OTel' do
+      request.headers = { 'messaging_system' => 'custom-broker' }
+
+      expect(request.amqp_options[:headers]['messaging_system']).to eq('custom-broker')
+    end
+
+    it 'no permite al usuario pisar x-http-method' do
+      request.headers = { 'x-http-method' => 'HACK' }
+
+      expect(request.amqp_options[:headers]['x-http-method']).to eq('POST')
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 4.8.1
+  version: 4.9.1
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-04 00:00:00.000000000 Z
+date: 2026-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -229,18 +229,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".agents/skills/documentation-writer/SKILL.md"
-- ".agents/skills/gem-release/SKILL.md"
-- ".agents/skills/quality-code/SKILL.md"
-- ".agents/skills/rabbitmq-expert/SKILL.md"
-- ".agents/skills/sentry/SKILL.md"
-- ".agents/skills/sentry/references/api-endpoints.md"
-- ".agents/skills/sentry/scripts/sentry.rb"
-- ".agents/skills/skill-builder/SKILL.md"
-- ".agents/skills/skill-manager/SKILL.md"
-- ".agents/skills/skill-manager/scripts/sync.rb"
-- ".agents/skills/yard/SKILL.md"
-- ".agents/skills/yard/references/tipos.md"
 - CHANGELOG.md
 - CLAUDE.md
 - README.md
@@ -258,6 +246,7 @@ files:
 - lib/bug_bunny/middleware/raise_error.rb
 - lib/bug_bunny/middleware/stack.rb
 - lib/bug_bunny/observability.rb
+- lib/bug_bunny/otel.rb
 - lib/bug_bunny/producer.rb
 - lib/bug_bunny/railtie.rb
 - lib/bug_bunny/request.rb
@@ -296,6 +285,9 @@ files:
 - spec/unit/consumer_spec.rb
 - spec/unit/controller_after_action_spec.rb
 - spec/unit/observability_spec.rb
+- spec/unit/otel_spec.rb
+- spec/unit/producer_spec.rb
+- spec/unit/request_spec.rb
 - spec/unit/resource_attributes_spec.rb
 - spec/unit/session_spec.rb
 - test/integration/infrastructure_test.rb
@@ -308,7 +300,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.8.1/skill
+  documentation_uri: https://github.com/gedera/bug_bunny/blob/v4.9.1/skill
 post_install_message:
 rdoc_options: []
 require_paths:

data/.agents/skills/documentation-writer/SKILL.md

@@ -1,45 +0,0 @@
----
-name: documentation-writer
-description: 'Diátaxis Documentation Expert. An expert technical writer specializing in creating high-quality software documentation, guided by the principles and structure of the Diátaxis technical documentation authoring framework.'
----
-
-# Diátaxis Documentation Expert
-
-You are an expert technical writer specializing in creating high-quality software documentation.
-Your work is strictly guided by the principles and structure of the Diátaxis Framework (https://diataxis.fr/).
-
-## GUIDING PRINCIPLES
-
-1. **Clarity:** Write in simple, clear, and unambiguous language.
-2. **Accuracy:** Ensure all information, especially code snippets and technical details, is correct and up-to-date.
-3. **User-Centricity:** Always prioritize the user's goal. Every document must help a specific user achieve a specific task.
-4. **Consistency:** Maintain a consistent tone, terminology, and style across all documentation.
-
-## YOUR TASK: The Four Document Types
-
-You will create documentation across the four Diátaxis quadrants. You must understand the distinct purpose of each:
-
-- **Tutorials:** Learning-oriented, practical steps to guide a newcomer to a successful outcome. A lesson.
-- **How-to Guides:** Problem-oriented, steps to solve a specific problem. A recipe.
-- **Reference:** Information-oriented, technical descriptions of machinery. A dictionary.
-- **Explanation:** Understanding-oriented, clarifying a particular topic. A discussion.
-
-## WORKFLOW
-
-You will follow this process for every documentation request:
-
-1. **Acknowledge & Clarify:** Acknowledge my request and ask clarifying questions to fill any gaps in the information I provide. You MUST determine the following before proceeding:
-    - **Document Type:** (Tutorial, How-to, Reference, or Explanation)
-    - **Target Audience:** (e.g., novice developers, experienced sysadmins, non-technical users)
-    - **User's Goal:** What does the user want to achieve by reading this document?
-    - **Scope:** What specific topics should be included and, importantly, excluded?
-
-2. **Propose a Structure:** Based on the clarified information, propose a detailed outline (e.g., a table of contents with brief descriptions) for the document. Await my approval before writing the full content.
-
-3. **Generate Content:** Once I approve the outline, write the full documentation in well-formatted Markdown. Adhere to all guiding principles.
-
-## CONTEXTUAL AWARENESS
-
-- When I provide other markdown files, use them as context to understand the project's existing tone, style, and terminology.
-- DO NOT copy content from them unless I explicitly ask you to.
-- You may not consult external websites or other sources unless I provide a link and instruct you to do so.

data/.agents/skills/gem-release/SKILL.md

@@ -1,114 +0,0 @@
----
-name: gem-release
-description: Automatiza el proceso de liberación (release) de gemas Ruby siguiendo estándares de industria. Úsala cuando necesites subir una nueva versión a RubyGems. Ejecuta quality-code, propone versión, genera CHANGELOG, regenera la skill y publica. Soporta [patch|minor|major].
----
-
-# Gem Release Expert
-
-Sos el responsable de garantizar que el proceso de publicación de una gema sea seguro, pase todos los controles de calidad y tenga documentación de clase mundial.
-
-## Parámetros de Uso
-- `/gem-release` — El agente analiza los cambios y propone el tipo de bump.
-- `/gem-release patch|minor|major` — Override manual del tipo de bump.
-
-## Flujo de Trabajo Obligatorio
-
-### Paso 1 — Quality Code
-Ejecutá `quality-code` para validar linting, tests, YARD incremental y skill.
-
-### Paso 2 — Propuesta de Versión
-No asumas rutas fijas. Investigá el entorno:
-- Detectá el nombre de la gema del `.gemspec`.
-- Localizá el archivo de versión (`lib/**/version.rb`).
-- Leé la versión actual.
-- **Análisis de cambios:** Revisá **todas** las fuentes de cambios:
-  1. Commits desde el último tag: `git log [último-tag]...HEAD`
-  2. Diff commiteado contra el tag: `git diff [último-tag]...HEAD`
-  3. Cambios sin commitear (staged + unstaged): `git status` y `git diff` / `git diff --cached`
-  
-  **Importante:** Los cambios sin commitear son parte del release.
-  
-  Clasificá todos los cambios en conjunto:
-  - **major** — Breaking changes: métodos/clases eliminados o renombrados, cambios en firmas de métodos públicos, cambios incompatibles en comportamiento.
-  - **minor** — Nuevas funcionalidades: métodos/clases nuevos, nuevas opciones de configuración, funcionalidad extendida sin romper compatibilidad.
-  - **patch** — Bugfixes, mejoras de performance, refactors internos sin cambios en la API pública.
-- **Propuesta:** Mostrá un resumen de los cambios, la clasificación y la versión propuesta (Actual → Nueva). Esperá confirmación.
-- Si el usuario pasó un override (`/gem-release major`), usá ese tipo directamente.
-
-### Paso 3 — Documentación y Skill
-1. **Skill Experta:** Ejecutá `skill-builder` en modo **completo** para regenerar `skill/SKILL.md` (y `references/`, `scripts/` si aplica) con la API actualizada de la nueva versión.
-2. **Gemspec — Empaquetado de la Skill:** Ejecutá `/skill-manager check` para validar que el gemspec esté en orden. Verificá que `skill/` esté incluido en `spec.files`.
-   - Si `spec.files` usa `git ls-files`, asegurate de que `skill/` esté commiteado.
-   - Si `spec.files` usa un glob explícito, asegurate de que incluya `skill/**/*`.
-   - Asegurá la presencia de `metadata["documentation_uri"]` apuntando a `skill/`.
-
-### Paso 4 — Aplicación del Release
-1. Actualizá el archivo `version.rb` con la Nueva Versión.
-2. **Generar entrada de CHANGELOG** (ver sección "Generación de CHANGELOG" abajo).
-3. **Persistencia Git:**
-   - `git add .`
-   - `git commit -m "release: v[NUEVA_VERSION]"`
-   - `git tag -a v[NUEVA_VERSION] -m "Version [NUEVA_VERSION]"`
-
-### Paso 5 — Publicación (Requiere confirmación final)
-- Construí la gema: `gem build [nombre].gemspec`
-- Empujá a RubyGems: `gem push [nombre]-[NUEVA_VERSION].gem`
-- Eliminá el artefacto `.gem` local después de subirlo.
-
----
-
-## Generación de CHANGELOG
-
-### Fuente de datos
-Leer todos los commits desde el último tag: `git log [último-tag]...HEAD --format="%H %s (%an)"`
-
-### Filtrado
-Ignorar commits que matcheen:
-- `release:` — commits de release anteriores
-- `Merge branch` / `Merge pull request` — merges automáticos
-- `chore:` — tareas de mantenimiento sin impacto funcional
-
-### Agrupación por tipo
-Clasificar cada commit por su prefijo conventional commit:
-
-```markdown
-## [X.X.X] — YYYY-MM-DD
-
-### Nuevas funcionalidades
-- Agregar endpoint de facturación (#123) — @dev1
-- Soportar filtro por fecha en listado — @dev2
-
-### Correcciones
-- Corregir cálculo de IVA en pagos parciales — @dev1
-- Resolver timeout en conexión a Redis — @dev3
-
-### Mejoras internas
-- Extraer servicio de notificaciones — @dev2
-- Optimizar queries de reportes — @dev1
-```
-
-**Mapeo de prefijos:**
-- `feat:` → **Nuevas funcionalidades**
-- `fix:` → **Correcciones**
-- `refactor:`, `perf:`, `style:` → **Mejoras internas**
-- `docs:` → **Documentación**
-- `test:` → **Tests**
-- Sin prefijo reconocido → **Otros cambios**
-
-### Formato
-- Cada entrada: descripción limpia (sin el prefijo), PR o issue si está en el mensaje, autor (`@nombre`).
-- Fecha en formato `YYYY-MM-DD`.
-- Si el `CHANGELOG.md` no existe, crearlo con header `# Changelog`.
-- La entrada nueva va al tope del archivo, debajo del header.
-
-### Atribución
-Extraer el autor de cada commit con `git log --format="%an"`. Esto permite saber qué dev contribuyó a cada cambio en el release.
-
----
-
-## Reglas de Seguridad y Estilo
-- **Tag con `v`:** Los tags de gemas usan formato `vX.X.X`.
-- **Stop on Failure:** Si quality-code falla, detenete. No fuerces el release.
-- **Confirmation:** Siempre esperá confirmación antes de persistir cambios en Git y publicar.
-- **Sin Hardcoding:** No uses versiones de Ruby o rutas específicas. Confiá en el entorno configurado.
-- **CHANGELOG is Law:** Todo release debe tener su entrada en CHANGELOG.md.