bug_bunny 4.8.1 → 4.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35c04cd113b0a3056cab1dcfda6d389fa996e13bb44992d4791bdef29b93fc7d
-  data.tar.gz: aa7d145fb3eb1d80f435c0541e1009df78a636019e6c6452be0e0a0515b1f1a8
+  metadata.gz: c70dd01d8d666fe56dbb95bc925ee431133cc0c342dc113a0775a4dddd4ce135
+  data.tar.gz: 2917d1105969a8173a8b9f70944d9b5839122a56185a5334db0e1c3a04594d2c
 SHA512:
-  metadata.gz: 9efee5f3deb6a52c76a361230032e040c964e22a1b52a2419873cb3d1c06159a1c52a042f424974a697a591342e8116aea1e39dd57e0bf71aa617ed5245e0860
-  data.tar.gz: 1f569f9e8b6fdfa2b48dd2270494a9a6b8f8aec2539ebadec5e20bc27f3ccd23407a340891b15c1567fe48ce593ee45a694b843987e5078852bb14d94ad37d70
+  metadata.gz: 241b7e0e684aa866d98940a2a3bc587ed13cf1da65c5708ff983c439078c40d823f13cac54ee8bf6d735dda138050c598c8cbf06759605523b8b2207de0e8e4d
+  data.tar.gz: 0b4f509d46dbe3ebd43bf8421bd9938bd2aa5d68ca23e639c3c1d232d5ad9d41b55cec0a4a0096cf8481e46c5d06163ce959d0f0167636d9084bf5d8aa3c9ba2

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [4.9.1] - 2026-04-06
+
+### Correcciones
+- Corregir `ArgumentError` en `Controller#process` con ActiveSupport 8.1: `Rails.logger.tagged` ahora pasa el logger como argumento al bloque (`yield self`), lo que causa error de aridad en lambdas estrictos. Se reemplaza `lambda do` por `proc do` en `core_execution` para ignorar argumentos extra. Compatible con Rails 6, 7 y 8. — @Gabriel
+
+## [4.9.0] - 2026-04-05
+
+### ✨ New Features
+* **OTel messaging semantic conventions:** BugBunny ahora emite los campos del estándar [OpenTelemetry semantic conventions for messaging](https://opentelemetry.io/docs/specs/otel/trace/semantic-conventions/messaging/) tanto en los headers AMQP de publish/reply como en los log events del consumer. Los campos emitidos son `messaging.system` (`"rabbitmq"`), `messaging.operation` (`"publish"` / `"process"`), `messaging.destination.name`, `messaging.rabbitmq.destination.routing_key` y `messaging.message.id` (cuando hay `correlation_id`). Permite que dashboards OTel-native (Tempo, Jaeger, Honeycomb) rendericen correctamente los spans de RabbitMQ y que ExisRay los consuma automáticamente desde `properties.headers`.
+* **`BugBunny::OTel` module:** Nuevo módulo con las constantes de las claves OTel y el helper `messaging_headers` para construir el hash de campos. Los headers del usuario pueden sobrescribir valores OTel como escape hatch, pero `x-http-method` sigue siendo inmutable.
+
 ## [4.8.1] - 2026-04-04
 
 ### Mejoras internas

data/CLAUDE.md

@@ -6,32 +6,38 @@ BugBunny es una gema Ruby que implementa una capa de enrutamiento RESTful sobre
 
 **Problema que resuelve:** Eliminar el acoplamiento directo entre microservicios via HTTP, usando RabbitMQ como bus de mensajes con la misma ergonomía de un framework web.
 
+## Documentación
+
+- **Para humanos**: `docs/` (5 archivos) + `README.md`. Ver README para índice.
+- **Para agentes AI**: `skill/SKILL.md` + `skill/references/`. Es la skill empaquetada que otros proyectos consumen via `skill-manager sync`.
+- **Nunca referenciar `skill/` desde `docs/` o `README.md`** — son audiencias distintas.
+
 ## Knowledge Base
 - Las skills en `.agents/skills/` incluyen conocimiento de dependencias.
 - Leer la skill de una dependencia ANTES de responder sobre ella.
 - Rebuild: `ruby .agents/skills/skill-manager/scripts/sync.rb`
 
-## Entorno
+### Entorno
 - Versión de Ruby: leer `.ruby-version`
 - Versión de Rails y gemas: leer `Gemfile.lock`
 - Gestor de Ruby: chruby (no usar rvm ni rbenv)
 - Package manager: Bundler
 
-## RuboCop
+### RuboCop
 - Usamos rubocop-rails-omakase como base.
 - Correr `bundle exec rubocop -a` antes de commitear.
 - No deshabilitar cops sin justificación en el PR.
 
-## YARD
+### YARD
 - Documentación incremental: si tocás un método, documentalo con YARD.
 - Consultar la skill `yard` para tags y tipos correctos.
 - Verificar cobertura: `bundle exec yard stats --list-undoc`
 
-## Testing
+### Testing
 - Framework: RSpec
 - Correr: `bundle exec rspec`
 - Todo código nuevo debe tener tests.
 
-## Releases
-- Gemas: `/gem-release`
-- Servicios: `/service-release build` o `/service-release deploy`
+### Releases o Nuevas versiones
+- Usar `/gem-release` para publicar nuevas versiones.
+- El GitHub Action publica a RubyGems automáticamente al pushear un tag `v*`.

data/README.md

@@ -214,15 +214,17 @@ BugBunny.consumer_middlewares.use TracingMiddleware
 
 ## Observability
 
-All internal events are emitted as structured key=value logs compatible with Datadog, CloudWatch, and ELK.
+BugBunny implementa de forma nativa las [OpenTelemetry semantic conventions for messaging](https://opentelemetry.io/docs/specs/otel/trace/semantic-conventions/messaging/), inyectando automáticamente campos como `messaging_system`, `messaging_operation`, `messaging_destination_name` y `messaging_message_id` tanto en los headers AMQP como en los log events estructurados.
+
+Todos los eventos internos se emiten como logs `key=value` compatibles con Datadog, CloudWatch, ELK y ExisRay.
 
 ```
-component=bug_bunny event=consumer.message_processed status=200 duration_s=0.012 controller=NodesController action=show
+component=bug_bunny event=consumer.message_processed status=200 duration_s=0.012 messaging_operation=process controller=NodesController action=show
 component=bug_bunny event=consumer.execution_error error_class=RuntimeError error_message="..." duration_s=0.003
 component=bug_bunny event=consumer.connection_error attempt_count=2 retry_in_s=10 error_message="..."
 ```
 
-Sensitive keys (`password`, `token`, `secret`, `api_key`, `authorization`, etc.) are automatically filtered to `[FILTERED]` in all log output.
+Las claves sensibles (`password`, `token`, `secret`, `api_key`, `authorization`, etc.) se filtran automáticamente a `[FILTERED]` en toda la salida de logs.
 
 ---
 

data/lib/bug_bunny/consumer.rb

@@ -152,6 +152,15 @@ module BugBunny
     def process_message(delivery_info, properties, body)
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+      # Campos OTel semantic conventions para los log events del consumer.
+      # Se mergean con ** en los safe_log de recepción y procesamiento.
+      otel_fields = BugBunny::OTel.messaging_headers(
+        operation: 'process',
+        destination: delivery_info.exchange,
+        routing_key: delivery_info.routing_key,
+        message_id: properties.correlation_id
+      )
+
       # 1. Validación de Headers (URL path)
       path = properties.type || (properties.headers && properties.headers['path'])
 
@@ -166,7 +175,7 @@ module BugBunny
       http_method = (headers_hash['x-http-method'] || headers_hash['method'] || 'GET').to_s.upcase
 
       safe_log(:info, 'consumer.message_received', method: http_method, path: path,
-                                                   routing_key: delivery_info.routing_key)
+                                                   routing_key: delivery_info.routing_key, **otel_fields)
       safe_log(:debug, 'consumer.message_received_body', body: body.truncate(200))
 
       # ===================================================================
@@ -239,10 +248,11 @@ module BugBunny
       session.channel.ack(delivery_info.delivery_tag)
 
       safe_log(:info, 'consumer.message_processed',
-               status: response_payload[:status],
+               response_status: response_payload[:status],
                duration_s: duration_s(start_time),
                controller: controller_class_name,
-               action: route_info[:action])
+               action: route_info[:action],
+               **otel_fields)
     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(' | '))
@@ -257,14 +267,20 @@ 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, correlation_id: correlation_id)
+      safe_log(:debug, 'consumer.rpc_reply', reply_to: reply_to, messaging_message_id: correlation_id)
+      otel_headers = BugBunny::OTel.messaging_headers(
+        operation: 'publish',
+        destination: '',
+        routing_key: reply_to,
+        message_id: correlation_id
+      )
       extra_headers = BugBunny.configuration.rpc_reply_headers&.call || {}
       session.channel.default_exchange.publish(
         payload.to_json,
         routing_key: reply_to,
         correlation_id: correlation_id,
         content_type: 'application/json',
-        headers: extra_headers
+        headers: otel_headers.transform_keys(&:to_s).merge(extra_headers)
       )
     end
 

data/lib/bug_bunny/controller.rb

@@ -165,7 +165,7 @@ module BugBunny
       current_arounds = resolve_callbacks(self.class.around_actions, action_name)
 
       # Definir el núcleo de ejecución
-      core_execution = lambda do
+      core_execution = proc do
         return unless run_before_actions(action_name)
 
         raise NameError, "Action '#{action_name}' not found in #{self.class.name}" unless respond_to?(action_name)

data/lib/bug_bunny/otel.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module BugBunny
+  # Helpers para emitir campos siguiendo las OTel semantic conventions for messaging.
+  # https://opentelemetry.io/docs/specs/otel/trace/semantic-conventions/messaging/
+  #
+  # Se usa tanto en el lado publisher (inyección en headers AMQP) como en el consumer
+  # (enriquecimiento de log events estructurados). Centraliza las claves para evitar
+  # strings mágicos dispersos y facilitar los tests.
+  module OTel
+    # Clave: sistema de mensajería. Siempre `"rabbitmq"` en BugBunny.
+    # Flat-naming siguiendo el patrón de ExisRay (underscore sin dots).
+    SYSTEM = :messaging_system
+    # Clave: tipo de operación (`publish`, `receive`, `process`).
+    OPERATION = :messaging_operation
+    # Clave: nombre del exchange destino.
+    DESTINATION = :messaging_destination_name
+    # Clave: routing key del mensaje (específica de RabbitMQ).
+    ROUTING_KEY = :messaging_routing_key
+    # Clave: identificador único del mensaje. En BugBunny se mapea a `correlation_id`.
+    MESSAGE_ID = :messaging_message_id
+
+    # Valor constante para {SYSTEM}.
+    SYSTEM_VALUE = 'rabbitmq'
+
+    # Construye el hash de campos OTel para messaging.
+    #
+    # Los campos son aptos tanto para inyectar en headers AMQP como para mergear
+    # en kwargs de log events estructurados.
+    #
+    # @param operation [String] Una de: `"publish"`, `"receive"`, `"process"`.
+    # @param destination [String, nil] Nombre del exchange destino (puede ser `""` para default exchange).
+    # @param routing_key [String, nil] Routing key final del mensaje.
+    # @param message_id [String, nil] Identificador del mensaje. Se omite si es `nil`.
+    # @return [Hash{String=>String}] Hash con los campos OTel de messaging.
+    def self.messaging_headers(operation:, destination:, routing_key:, message_id: nil)
+      fields = {
+        SYSTEM => SYSTEM_VALUE,
+        OPERATION => operation,
+        DESTINATION => destination.to_s,
+        ROUTING_KEY => routing_key.to_s
+      }
+      fields[MESSAGE_ID] = message_id.to_s if message_id
+      fields
+    end
+  end
+end

data/lib/bug_bunny/producer.rb

@@ -79,7 +79,7 @@ module BugBunny
       begin
         fire(request)
 
-        safe_log(:debug, 'producer.rpc_waiting', correlation_id: cid, timeout_s: wait_timeout)
+        safe_log(:debug, 'producer.rpc_waiting', messaging_message_id: cid, timeout_s: wait_timeout)
 
         # Bloqueamos el hilo aquí hasta que llegue la respuesta o expire el timeout
         result = future.value(wait_timeout)
@@ -88,7 +88,8 @@ module BugBunny
 
         BugBunny.configuration.on_rpc_reply&.call(result[:headers])
 
-        safe_log(:debug, 'producer.rpc_response_received', correlation_id: cid)
+        safe_log(:debug, 'producer.rpc_response_received',
+                 messaging_system: 'rabbitmq', messaging_operation: 'receive', messaging_message_id: cid)
 
         parse_response(result[:body])
       ensure
@@ -109,13 +110,21 @@ module BugBunny
       rk = request.final_routing_key
       id = request.correlation_id
 
+      otel_fields = BugBunny::OTel.messaging_headers(
+        operation: 'publish',
+        destination: request.exchange,
+        routing_key: rk,
+        message_id: id
+      )
+
       # 📊 LOGGING DE OBSERVABILIDAD: Calculamos las opciones finales para mostrarlas en consola
       final_x_opts = BugBunny::Session::DEFAULT_EXCHANGE_OPTIONS
                      .merge(BugBunny.configuration.exchange_options || {})
                      .merge(request.exchange_options || {})
 
-      safe_log(:info, 'producer.publish', method: verb, path: target, routing_key: rk, correlation_id: id)
-      safe_log(:debug, 'producer.publish_detail', exchange: request.exchange, exchange_opts: final_x_opts)
+      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)
     end
 

data/lib/bug_bunny/request.rb

@@ -86,10 +86,22 @@ module BugBunny
     # **Importante:** Inyecta el verbo HTTP en los headers bajo la clave `x-http-method`.
     # Esto permite al Consumer enrutar correctamente a la acción del controlador.
     #
+    # También inyecta los campos de OTel semantic conventions for messaging
+    # (ver {BugBunny::OTel}) con `operation=publish`. Los headers del usuario
+    # pueden sobrescribir los valores OTel (escape hatch); `x-http-method`
+    # nunca se pisa porque es lo último en el merge.
+    #
     # @return [Hash] Opciones listas para pasar a `exchange.publish`.
     def amqp_options
-      # Inyectamos el verbo HTTP en los headers para el Router del Consumer
-      final_headers = headers.merge('x-http-method' => method.to_s.upcase)
+      otel_headers = BugBunny::OTel.messaging_headers(
+        operation: 'publish',
+        destination: exchange,
+        routing_key: final_routing_key,
+        message_id: correlation_id
+      )
+      # Orden del merge: OTel base -> headers del usuario -> x-http-method (inmutable)
+      # OTel keys son symbols internamente; los stringificamos para Bunny AMQP headers.
+      final_headers = otel_headers.transform_keys(&:to_s).merge(headers).merge('x-http-method' => method.to_s.upcase)
 
       {
         type: final_type,

data/lib/bug_bunny/version.rb

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

data/lib/bug_bunny.rb

@@ -6,6 +6,7 @@ require_relative 'bug_bunny/version'
 require_relative 'bug_bunny/exception'
 require_relative 'bug_bunny/configuration'
 require_relative 'bug_bunny/observability'
+require_relative 'bug_bunny/otel'
 require_relative 'bug_bunny/routing/route_set'
 require_relative 'bug_bunny/middleware/base'
 require_relative 'bug_bunny/middleware/stack'

data/skill/SKILL.md

@@ -68,8 +68,31 @@ Skill de conocimiento completo sobre BugBunny. Consultame para cualquier pregunt
 | `BugBunny::Routing::RouteSet` | DSL de rutas: `resources`, `namespace`, `member`, `collection`. |
 | `BugBunny::Observability` | Mixin de logging estructurado. `safe_log` nunca lanza excepciones. Filtra keys sensibles. |
 | `BugBunny::Middleware::Stack` | Builder de middlewares client-side (onion architecture tipo Faraday). |
-| `BugBunny::Request` | Value object del mensaje saliente con metadata AMQP completa. |
-| `BugBunny::Railtie` | Integración Rails: autoload de `app/rabbit`, fork safety (Puma, Spring). |
+| 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). |
+
+---
+
+## Observability: OpenTelemetry
+
+BugBunny implementa las [OpenTelemetry semantic conventions for messaging](https://opentelemetry.io/docs/specs/otel/trace/semantic-conventions/messaging/) de forma nativa para garantizar la trazabilidad entre servicios en entornos distribuidos.
+
+### Campos Estándar (Flat-naming)
+
+| Campo | Valor / Origen | Propósito |
+|---|---|---|
+| `messaging_system` | `"rabbitmq"` | Identifica el broker. |
+| `messaging_operation` | `"publish"`, `"receive"`, `"process"` | Tipo de interacción. |
+| `messaging_destination_name` | `exchange_name` | Exchange destino (o `""` para default). |
+| `messaging_routing_key` | `routing_key` | Clave de ruteo final. |
+| `messaging_message_id` | `correlation_id` | ID único para correlación y traza. |
+
+### Inyección y Extracción
+
+- **Publisher:** Inyecta estos campos en los headers AMQP bajo el prefijo `messaging_`. El usuario puede sobrescribirlos como *escape hatch* desde `headers`.
+- **Consumer:** Extrae los campos de los logs estructurados sin mutar los headers originales. Los eventos `consumer.message_received` y `consumer.message_processed` incluyen estos campos automáticamente.
+- **RPC Reply:** El consumer inyecta los mismos campos en el reply para cerrar el ciclo de traza del lado del cliente.
 
 ---
 

data/skill/references/client-middleware.md

@@ -107,6 +107,23 @@ El método `call` del `Base` invoca `on_request`, delega a `@app.call`, y luego
 
 **JsonResponse** — Auto-parsea `response['body']` de String a Hash/Array. Aplica `HashWithIndifferentAccess` si disponible.
 
+## OpenTelemetry: Publisher Injection
+
+El `Producer` (vía `Request#amqp_options`) inyecta automáticamente los campos de OTel semantic conventions en los headers AMQP del mensaje saliente.
+
+```ruby
+# Headers inyectados automáticamente
+{
+  'messaging_system' => 'rabbitmq',
+  'messaging_operation' => 'publish',
+  'messaging_destination_name' => 'exchange_name',
+  'messaging_routing_key' => 'rk',
+  'messaging_message_id' => 'uuid'
+}
+```
+
+El orden de merge es: **OTel base** → **headers del usuario** → **x-http-method**. Esto permite al desarrollador sobrescribir valores de OTel si es necesario, pero garantiza que el ruteo interno (`x-http-method`) se mantenga íntegro.
+
 ## Request Object
 
 Value object con toda la metadata AMQP:

data/skill/references/consumer.md

@@ -18,13 +18,31 @@ consumer = BugBunny::Consumer.subscribe(
 ## Flujo de Procesamiento
 
 1. Escucha en la queue con `manual_ack: true`.
-2. Valida que el mensaje tenga header `type` (path).
-3. Parsea el método HTTP de headers (`x-http-method` o `method`).
-4. Reconoce la ruta con `BugBunny.routes.recognize(method, path)`.
-5. Resuelve el controlador validando herencia de `BugBunny::Controller`.
-6. Ejecuta consumer middlewares → controller callbacks → acción.
-7. Responde via `reply_to` si está presente (RPC).
-8. Hace `ack` del mensaje. En caso de error, `reject`.
+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`.
+
+## Observability: OTel Fields
+
+El consumer construye automáticamente el hash de campos OTel al inicio de `process_message`:
+
+```ruby
+otel_fields = BugBunny::OTel.messaging_headers(
+  operation: 'process',
+  destination: delivery_info.exchange,
+  routing_key: delivery_info.routing_key,
+  message_id: properties.correlation_id
+)
+```
+
+Estos campos se mergean en todos los eventos de log del ciclo de vida del mensaje, permitiendo que ExisRay los rastree sin necesidad de propagarlos manualmente en los headers del usuario.
 
 ## Lifecycle
 

data/skills.lock

@@ -1,9 +1,18 @@
 ---
-synced_at: '2026-04-04 12:24:37'
+synced_at: '2026-04-06 14:08:54'
 skills:
+- name: agent-review
+  scope: local
+  path: "/Users/gabriel/src/gems/bug_bunny/.agents/skills/agent-review"
+- name: ai-reports
+  scope: local
+  path: "/Users/gabriel/src/gems/bug_bunny/.agents/skills/ai-reports"
 - name: documentation-writer
   scope: local
   path: "/Users/gabriel/src/gems/bug_bunny/.agents/skills/documentation-writer"
+- name: find-skills
+  scope: local
+  path: "/Users/gabriel/src/gems/bug_bunny/.agents/skills/find-skills"
 - name: gem-release
   scope: local
   path: "/Users/gabriel/src/gems/bug_bunny/.agents/skills/gem-release"

data/skills.yml

@@ -1,19 +1,44 @@
 mcps:
   - github
+  - clickup
 skills:
-  - name: skill-manager
+  skill-manager:
     repo: sequre/ai_knowledge
-  - name: yard
+    scope: local
+  yard:
     repo: sequre/ai_knowledge
-  - name: quality-code
+    scope: local
+  quality-code:
     repo: sequre/ai_knowledge
-  - name: gem-release
+    scope: local
+  gem-release:
     repo: sequre/ai_knowledge
-  - name: skill-builder
+    scope: local
+  skill-builder:
     repo: sequre/ai_knowledge
-  - name: rabbitmq-expert
-    repo: martinholovsky/claude-skills-generator
-    path: skills/rabbitmq-expert
-  - name: documentation-writer
+    scope: local
+  ai-reports:
+    repo: sequre/ai_knowledge
+    scope: local
+    environment:
+      space_id: "${AI_REPORTS_SPACE_ID}"
+      bug_reports_list_id: "${AI_REPORTS_BUG_REPORTS_LIST_ID}"
+      improvements_list_id: "${AI_REPORTS_IMPROVEMENTS_LIST_ID}"
+  agent-review:
+    repo: sequre/ai_knowledge
+    scope: local
+    environment:
+      space_id: "${AGENT_REVIEW_SAPCE_ID}"
+      list_id: "${AGENT_LIST_ID}"
+  documentation-writer:
     repo: github/awesome-copilot
     path: skills/documentation-writer
+    scope: local
+  find-skills:
+    repo: vercel-labs/skills
+    path: skills/find-skills
+    scope: local
+  rabbitmq-expert:
+    repo: martinholovsky/claude-skills-generator
+    path: skills/rabbitmq-expert
+    scope: local

data/spec/integration/consumer_middleware_spec.rb

@@ -24,7 +24,7 @@ class TrackingMiddleware < BugBunny::ConsumerMiddleware::Base
   def call(delivery_info, properties, body)
     self.class.calls << {
       routing_key: delivery_info.routing_key,
-      headers:     properties.headers
+      headers: properties.headers
     }
     @app.call(delivery_info, properties, body)
   end
@@ -45,7 +45,7 @@ RSpec.describe 'Consumer Middleware Stack', :integration do
     BugBunny.configure { |c| c.controller_namespace = 'BugBunny::Controllers' }
     # Limpiamos el middleware para no afectar otros specs
     BugBunny.configuration.instance_variable_set(:@consumer_middlewares,
-      BugBunny::ConsumerMiddleware::Stack.new)
+                                                 BugBunny::ConsumerMiddleware::Stack.new)
   end
 
   it 'ejecuta el middleware antes de process_message' do
@@ -82,5 +82,26 @@ RSpec.describe 'Consumer Middleware Stack', :integration do
       BugBunny.configuration.rpc_reply_headers = nil
       BugBunny.configuration.on_rpc_reply      = nil
     end
+
+    it 'incluye los campos OTel semantic conventions en el reply' do
+      received_headers = nil
+
+      BugBunny.configuration.rpc_reply_headers = -> { { 'X-Test-Header' => 'from-consumer' } }
+      BugBunny.configuration.on_rpc_reply = ->(headers) { received_headers = headers }
+
+      with_running_worker(queue: queue, exchange: exchange, routing_key: 'ping') do
+        client.request('ping', method: :get, exchange: exchange, exchange_type: 'topic', routing_key: 'ping')
+      end
+
+      expect(received_headers).to include(
+        'messaging_system' => 'rabbitmq',
+        'messaging_operation' => 'publish',
+        'X-Test-Header' => 'from-consumer'
+      )
+      expect(received_headers['messaging_message_id']).not_to be_nil
+    ensure
+      BugBunny.configuration.rpc_reply_headers = nil
+      BugBunny.configuration.on_rpc_reply      = nil
+    end
   end
 end