bug_bunny 5.2.0 → 5.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.rspec +2 -0
- data/AGENTS.md +3 -2
- data/CHANGELOG.md +29 -0
- data/CLAUDE.md +1 -1
- data/README.md +42 -3
- data/Rakefile +9 -1
- data/docs/behavior/behavior.md +25 -3
- data/docs/config/configuracion.md +53 -43
- data/docs/errors/errors.md +4 -2
- data/docs/release/release.md +13 -9
- data/docs/test/testing.md +16 -6
- data/lib/bug_bunny/configuration.rb +11 -0
- data/lib/bug_bunny/consumer_middleware/rails_executor.rb +33 -0
- data/lib/bug_bunny/consumer_middleware.rb +13 -0
- data/lib/bug_bunny/railtie.rb +14 -3
- data/lib/bug_bunny/version.rb +1 -1
- data/lib/generators/bug_bunny/install/install_generator.rb +0 -42
- data/skill/SKILL.md +13 -7
- data/skill/references/consumer.md +9 -0
- data/skill/references/testing.md +4 -1
- data/spec/rails/app.rb +70 -0
- data/spec/rails/consumer_rails_executor_spec.rb +165 -0
- data/spec/rails/install_generator_spec.rb +66 -0
- data/spec/rails/rails_helper.rb +6 -0
- data/spec/rails/railtie_rake_tasks_spec.rb +21 -0
- data/spec/unit/configuration_spec.rb +6 -0
- data/spec/unit/consumer_middleware_spec.rb +13 -0
- data/spec/unit/consumer_rails_executor_outside_rails_spec.rb +19 -0
- metadata +53 -4
- data/lib/tasks/bug_bunny.rake +0 -50
data/lib/bug_bunny/railtie.rb
CHANGED
|
@@ -8,6 +8,7 @@ module BugBunny
|
|
|
8
8
|
# Esta clase es responsable de:
|
|
9
9
|
# 1. Registrar la carpeta `app/rabbit` en el autoloader de Rails (Zeitwerk).
|
|
10
10
|
# 2. Gestionar la seguridad de las conexiones durante el "forking" de procesos (Puma/Spring).
|
|
11
|
+
# 3. Envolver cada mensaje del Consumer con el executor de Rails (ver {ConsumerMiddleware::RailsExecutor}).
|
|
11
12
|
#
|
|
12
13
|
# @see https://guides.rubyonrails.org/engines.html#railtie
|
|
13
14
|
class Railtie < ::Rails::Railtie
|
|
@@ -34,9 +35,19 @@ module BugBunny
|
|
|
34
35
|
end
|
|
35
36
|
end
|
|
36
37
|
|
|
37
|
-
# 3.
|
|
38
|
-
|
|
39
|
-
|
|
38
|
+
# 3. Executor de Rails alrededor de cada mensaje del Consumer
|
|
39
|
+
#
|
|
40
|
+
# El Consumer procesa en el hilo de Bunny, que Rails no conoce: sin esto, el estado por hilo
|
|
41
|
+
# pasa de un mensaje al siguiente. Va al principio de la cadena (`prepend`, no `use`) para que
|
|
42
|
+
# envuelva también a los middlewares que cargan ese estado, como el de tracing de ExisRay, que
|
|
43
|
+
# se registra en su propio `after_initialize` y en un orden que no controlamos.
|
|
44
|
+
config.after_initialize do
|
|
45
|
+
# Sin un `BugBunny.configure` previo, vale la configuración por default; un `configure` posterior la reusa.
|
|
46
|
+
BugBunny.configuration ||= BugBunny::Configuration.new
|
|
47
|
+
if BugBunny.configuration.consumer_rails_executor
|
|
48
|
+
require_relative 'consumer_middleware/rails_executor'
|
|
49
|
+
BugBunny.consumer_middlewares.prepend(BugBunny::ConsumerMiddleware::RailsExecutor)
|
|
50
|
+
end
|
|
40
51
|
end
|
|
41
52
|
|
|
42
53
|
# 4. Hook de Spring (Preloader)
|
data/lib/bug_bunny/version.rb
CHANGED
|
@@ -41,48 +41,6 @@ module BugBunny
|
|
|
41
41
|
empty_directory 'app/bug_bunny/controllers'
|
|
42
42
|
create_file 'app/bug_bunny/controllers/.keep', ''
|
|
43
43
|
end
|
|
44
|
-
|
|
45
|
-
# Escribe el bloque inicial de BugBunny en CLAUDE.md del proyecto consumidor.
|
|
46
|
-
#
|
|
47
|
-
# Si CLAUDE.md no existe, crea uno mínimo con la sección correspondiente.
|
|
48
|
-
# Si ya existe, agrega la sección `## Gemas internas` con el bloque de bug_bunny.
|
|
49
|
-
# En ambos casos, el rake task `bug_bunny:sync` se encarga de las actualizaciones futuras.
|
|
50
|
-
#
|
|
51
|
-
# @return [void]
|
|
52
|
-
def update_claude_md
|
|
53
|
-
spec = Gem::Specification.find_by_name('bug_bunny')
|
|
54
|
-
version = spec.version.to_s
|
|
55
|
-
docs_path = File.join(spec.gem_dir, 'docs', 'ai')
|
|
56
|
-
|
|
57
|
-
block = <<~BLOCK
|
|
58
|
-
## Gemas internas
|
|
59
|
-
|
|
60
|
-
### bug_bunny
|
|
61
|
-
- **Version:** #{version}
|
|
62
|
-
- **Docs:** #{docs_path}
|
|
63
|
-
- **Updated:** #{Time.now.strftime('%Y-%m-%d')}
|
|
64
|
-
BLOCK
|
|
65
|
-
|
|
66
|
-
claude_md = File.join(destination_root, 'CLAUDE.md')
|
|
67
|
-
|
|
68
|
-
if File.exist?(claude_md)
|
|
69
|
-
content = File.read(claude_md)
|
|
70
|
-
if content.include?('### bug_bunny')
|
|
71
|
-
say_status :skip, 'CLAUDE.md already has a bug_bunny block — run `rake bug_bunny:sync` to update'
|
|
72
|
-
elsif content.include?('## Gemas internas')
|
|
73
|
-
inject_into_file 'CLAUDE.md', "\n#{block.lines.drop(2).join}", after: "## Gemas internas\n"
|
|
74
|
-
say_status :update, 'Added bug_bunny block to existing ## Gemas internas section in CLAUDE.md'
|
|
75
|
-
else
|
|
76
|
-
append_to_file 'CLAUDE.md', "\n#{block}"
|
|
77
|
-
say_status :update, 'Added ## Gemas internas section to CLAUDE.md'
|
|
78
|
-
end
|
|
79
|
-
else
|
|
80
|
-
create_file 'CLAUDE.md', "# #{Rails.application.class.module_parent_name}\n\n#{block}"
|
|
81
|
-
say_status :create, 'CLAUDE.md created with bug_bunny block'
|
|
82
|
-
end
|
|
83
|
-
|
|
84
|
-
say ' Add `bundle exec rake bug_bunny:sync` to bin/setup to keep this block up to date.'
|
|
85
|
-
end
|
|
86
44
|
end
|
|
87
45
|
end
|
|
88
46
|
end
|
data/skill/SKILL.md
CHANGED
|
@@ -19,10 +19,12 @@ Gema Ruby: capa de routing RESTful sobre AMQP/RabbitMQ. Microservicios se comuni
|
|
|
19
19
|
|
|
20
20
|
## Contrato resumido (piso mínimo)
|
|
21
21
|
|
|
22
|
-
> Resume el contrato de **`bug_bunny` 5.
|
|
22
|
+
> Resume el contrato de **`bug_bunny` 5.4.0** (anclado a `v5.4.0`). Suficiente para el uso típico sin abrir el detalle; el detalle version-locked está en el **Índice de artefactos** de abajo. Antipatrones/API completa: más abajo (embebido interim, ver Cobertura y fronteras).
|
|
23
23
|
>
|
|
24
24
|
> **Si venís de 5.1.x, un cambio de conducta (5.2.0):** una entrega cuyo middleware —o `handle_fatal_error`— levanta **antes del ack** ahora se **rechaza sin requeue** (evento `consumer.delivery_failed`), en `subscribe` y en `drain`. Antes quedaba sin ack ni reject y trababa el consumidor. Si un middleware levantaba a propósito para que el mensaje se reintentara, ahora el mensaje se pierde: el reintento es tuyo. Detalle en [`docs/behavior/behavior.md`](../docs/behavior/behavior.md).
|
|
25
25
|
>
|
|
26
|
+
> **Si venís de 5.2.x, dos cambios de conducta dentro de Rails (5.3.0):** cada mensaje del Consumer corre dentro de `Rails.application.executor.wrap`. En Rails ≥ 7.0, un error que escapa del mensaje además se reporta a `Rails.error` (el mensaje se sigue rechazando sin requeue), y la caché de queries de ActiveRecord queda prendida durante cada mensaje. Se apagan con `config.consumer_rails_executor = false`. Detalle en [`docs/behavior/behavior.md`](../docs/behavior/behavior.md) y [`docs/config/configuracion.md`](../docs/config/configuracion.md).
|
|
27
|
+
>
|
|
26
28
|
> **Si venís de 4.x, dos breaking a mirar antes de subir:** `5.0.0` eliminó la constante pública `BugBunny::SecurityError` (un `rescue BugBunny::SecurityError` que sobreviva revienta con `NameError` y **enmascara la excepción original**) y `4.18.0` cambió el wrapping `Bunny::Exception` → `CommunicationError`. Detalle en `CHANGELOG.md`.
|
|
27
29
|
|
|
28
30
|
**Símbolos públicos clave**
|
|
@@ -63,16 +65,16 @@ client.publish('events', body: { type: 'x' }) # => { 'status' => 202 }
|
|
|
63
65
|
|
|
64
66
|
## Índice de artefactos (fuente de verdad)
|
|
65
67
|
|
|
66
|
-
El detalle vive en `docs/<capa>/` (modelo `dev-*`); esta skill **indexa y resume**, no duplica. Links relativos = version-locked (mismo tag del release, `v5.
|
|
68
|
+
El detalle vive en `docs/<capa>/` (modelo `dev-*`); esta skill **indexa y resume**, no duplica. Links relativos = version-locked (mismo tag del release, `v5.4.0`; `gemspec.files` incluye `docs/**`, así que estos archivos viajan dentro del `.gem` que ya tenés instalado).
|
|
67
69
|
|
|
68
70
|
| Capa | Artefacto | Estado |
|
|
69
71
|
|---|---|---|
|
|
70
72
|
| Glosario de dominio | [docs/glossary/glossary.md](../docs/glossary/glossary.md) | parcial, acreta por PR |
|
|
71
|
-
| Comportamiento (flujos) | [docs/behavior/behavior.md](../docs/behavior/behavior.md) | completa —
|
|
73
|
+
| Comportamiento (flujos) | [docs/behavior/behavior.md](../docs/behavior/behavior.md) | completa — 8 flujos |
|
|
72
74
|
| Configuración | [docs/config/configuracion.md](../docs/config/configuracion.md) | §a-§e/§i estructura + §f/§g/§h enrich — completa |
|
|
73
75
|
| Dependencias consumidas | [docs/consumed/rabbitmq.md](../docs/consumed/rabbitmq.md) | §a/§b/§d estructura + §c/§e enrich |
|
|
74
76
|
| Errores | [docs/errors/errors.md](../docs/errors/errors.md) | §a/§b/§d completas; §c política inferida (verificación humana pendiente) |
|
|
75
|
-
| Test | [docs/test/testing.md](../docs/test/testing.md) | §a-§h —
|
|
77
|
+
| Test | [docs/test/testing.md](../docs/test/testing.md) | §a-§h — 18 unit / 8 integration / 1 rails (`spec/rails/`, en su propio proceso) |
|
|
76
78
|
| Release | [docs/release/release.md](../docs/release/release.md) | completa (régimen gema: build→publish; §e/f/g n/a) |
|
|
77
79
|
| Datos | — | n/a — gema sin DB |
|
|
78
80
|
| Eventos | — | n/a — la gema **es** el transporte; no declara catálogo de eventos de dominio propio |
|
|
@@ -139,7 +141,8 @@ Por RFC-008 §2: no se fabrica la capa, no se borra contrato sin destino, no se
|
|
|
139
141
|
| `BugBunny::Producer` | Publica mensajes. Implementa tres modos: `#fire` (async), `#confirmed` (sync con `wait_for_confirms`) y `#rpc` (direct reply-to + `Concurrent::IVar`). |
|
|
140
142
|
| `BugBunny::Client` | API de alto nivel. Pool de conexiones y middleware stack (onion architecture). |
|
|
141
143
|
| `BugBunny::Consumer` | Subscribe loop con health check. Rutea mensajes via `BugBunny.routes`. |
|
|
142
|
-
| `BugBunny::ConsumerMiddleware::Stack` | Pipeline de middlewares antes de `process_message`. Thread-safe. |
|
|
144
|
+
| `BugBunny::ConsumerMiddleware::Stack` | Pipeline de middlewares antes de `process_message`. Thread-safe. `use` agrega al final; `prepend` pone al principio (envuelve a todos). |
|
|
145
|
+
| `BugBunny::ConsumerMiddleware::RailsExecutor` | Sólo en Rails: envuelve cada mensaje con `Rails.application.executor.wrap`, para que el estado por hilo (`CurrentAttributes`, conexión de AR) no pase al siguiente. Lo registra el Railtie primero; se apaga con `config.consumer_rails_executor = false`. |
|
|
143
146
|
| `BugBunny::Controller` | Base class tipo Rails. `before_action`, `around_action`, `after_action`, `rescue_from`, `render`. |
|
|
144
147
|
| `BugBunny::Resource` | ORM sobre AMQP. `find`, `where`, `create`, `save`, `destroy`. ActiveModel validations y callbacks. |
|
|
145
148
|
| `BugBunny::Routing::RouteSet` | DSL de rutas: `resources`, `namespace`, `member`, `collection`. |
|
|
@@ -147,7 +150,7 @@ Por RFC-008 §2: no se fabrica la capa, no se borra contrato sin destino, no se
|
|
|
147
150
|
| `BugBunny::Middleware::Stack` | Builder de middlewares client-side (onion architecture tipo Faraday). |
|
|
148
151
|
| BugBunny::Request | Value object del mensaje saliente con metadata AMQP completa. |
|
|
149
152
|
| BugBunny::OTel | Helpers para emitir campos siguiendo las OTel semantic conventions for messaging. |
|
|
150
|
-
| BugBunny::Railtie | Integración Rails: autoload de `app/rabbit`, fork safety (Puma, Spring). |
|
|
153
|
+
| BugBunny::Railtie | Integración Rails: autoload de `app/rabbit`, fork safety (Puma, Spring), executor de Rails alrededor de cada mensaje del Consumer. |
|
|
151
154
|
|
|
152
155
|
---
|
|
153
156
|
|
|
@@ -368,7 +371,7 @@ client.publish('foo', confirmed: true, mandatory: true, return_raise: false, bod
|
|
|
368
371
|
## FAQ
|
|
369
372
|
|
|
370
373
|
### ¿Cómo se integra con Rails?
|
|
371
|
-
`rails generate bug_bunny:install` genera el inicializador
|
|
374
|
+
`rails generate bug_bunny:install` genera el inicializador y crea `app/bug_bunny/controllers/`. El pool se define en el inicializador y se asigna a `BugBunny::Resource.connection_pool`.
|
|
372
375
|
|
|
373
376
|
### ¿Cómo funciona el Health Check?
|
|
374
377
|
El consumer ejecuta un check periódico (default 60s) que verifica la conexión AMQP con un `queue.declare(passive: true)`. Si `health_check_file` está configurado, actualiza su mtime. En Kubernetes, usar un `livenessProbe` tipo `exec` que verifique recencia del archivo.
|
|
@@ -386,6 +389,9 @@ Cada slot del pool cachea su `Session` y `Producer` durante su vida útil. Esto
|
|
|
386
389
|
### ¿Cómo funciona fork safety?
|
|
387
390
|
`BugBunny::Railtie` registra hooks en `ActiveSupport::ForkTracker` (Rails 7.1+), `Puma.events.on_worker_boot` y `Spring.after_fork` para llamar `BugBunny.disconnect` y evitar sockets TCP heredados.
|
|
388
391
|
|
|
392
|
+
### ¿Por qué el estado de un mensaje no pasa al siguiente?
|
|
393
|
+
El Consumer procesa en el hilo de trabajo de Bunny, que Rails no conoce. En Rails, el Railtie registra `ConsumerMiddleware::RailsExecutor` al principio de la cadena (`prepend`), que envuelve cada mensaje con `Rails.application.executor.wrap`: al entrar y al salir se resetean los `CurrentAttributes`, y al salir la conexión de ActiveRecord vuelve al pool. Va primero para envolver también a los middlewares que cargan estado por hilo (el de tracing de ExisRay). **Cambios de conducta:** en Rails ≥ 7.0, un error que escapa del mensaje además se reporta a `Rails.error` con `handled: false` (el mensaje se sigue rechazando sin requeue); y la caché de queries de AR queda prendida durante cada mensaje (en el hilo de Bunny estaba apagada). Apagado: `config.consumer_rails_executor = false`.
|
|
394
|
+
|
|
389
395
|
---
|
|
390
396
|
|
|
391
397
|
## Antipatrones
|
|
@@ -87,6 +87,15 @@ BugBunny.configuration.consumer_middlewares.use MyTracing::Middleware
|
|
|
87
87
|
BugBunny.configuration.consumer_middlewares.use MyAuth::Middleware
|
|
88
88
|
```
|
|
89
89
|
|
|
90
|
+
`use` agrega al final de la cadena; `prepend` pone al principio, envolviendo a todos.
|
|
91
|
+
|
|
92
|
+
### Executor de Rails (automático en Rails)
|
|
93
|
+
|
|
94
|
+
En Rails, el Railtie registra `BugBunny::ConsumerMiddleware::RailsExecutor` **primero**: cada mensaje corre dentro
|
|
95
|
+
de `Rails.application.executor.wrap`, así que los `CurrentAttributes` no pasan de un mensaje al siguiente y la
|
|
96
|
+
conexión de ActiveRecord vuelve al pool. Cambios de conducta: en Rails ≥ 7.0, un error que escapa del mensaje además
|
|
97
|
+
se reporta a `Rails.error`, y la caché de queries de AR queda prendida durante cada mensaje. Se apaga con `config.consumer_rails_executor = false` (desde `config/initializers`).
|
|
98
|
+
|
|
90
99
|
### Crear Middleware
|
|
91
100
|
|
|
92
101
|
```ruby
|
data/skill/references/testing.md
CHANGED
|
@@ -131,7 +131,10 @@ TEST_POOL = ConnectionPool.new(size: 5) { BugBunny.create_connection }
|
|
|
131
131
|
## Ejecutar Tests
|
|
132
132
|
|
|
133
133
|
```bash
|
|
134
|
-
bundle exec
|
|
134
|
+
bundle exec rake # Todos: spec/ y spec/rails/ (cada una en su proceso)
|
|
135
|
+
bundle exec rspec # spec/, sin Rails (.rspec excluye spec/rails/ si no se la pide)
|
|
136
|
+
bundle exec rspec spec/rails # Solo el Railtie (igual que rake spec:rails)
|
|
137
|
+
bundle exec rake spec:rails # Solo el Railtie, con una app Rails mínima
|
|
135
138
|
bundle exec rspec spec/unit/ # Solo unit
|
|
136
139
|
bundle exec rspec spec/integration/ # Solo integration (requiere RabbitMQ)
|
|
137
140
|
bundle exec rspec spec/unit/session_spec.rb # Archivo específico
|
data/spec/rails/app.rb
ADDED
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
# App Rails mínima para probar el Railtie de BugBunny con Rails de verdad (ActiveRecord sobre SQLite
|
|
4
|
+
# en memoria).
|
|
5
|
+
#
|
|
6
|
+
# Rails se inicializa una vez por proceso, así que estos specs corren en su propio proceso
|
|
7
|
+
# (`rake spec:rails`): la suite de `spec/` sigue probando la gema fuera de Rails. Para bootear con
|
|
8
|
+
# otra configuración, el spec corre este archivo solo, en un subproceso (`ruby spec/rails/app.rb`),
|
|
9
|
+
# y lee la cadena de middlewares que imprime.
|
|
10
|
+
#
|
|
11
|
+
# `BUG_BUNNY_SPEC_EXECUTOR=off` bootea con `config.consumer_rails_executor = false`.
|
|
12
|
+
# `BUG_BUNNY_SPEC_CONFIGURE=none` bootea sin llamar a `BugBunny.configure` ni registrar otros middlewares:
|
|
13
|
+
# la configuración queda la de default.
|
|
14
|
+
|
|
15
|
+
ENV['RAILS_ENV'] = 'test'
|
|
16
|
+
ENV['DATABASE_URL'] = 'sqlite3::memory:'
|
|
17
|
+
|
|
18
|
+
require 'bundler/setup'
|
|
19
|
+
require 'logger'
|
|
20
|
+
require 'rails'
|
|
21
|
+
require 'active_record/railtie'
|
|
22
|
+
require 'bug_bunny'
|
|
23
|
+
|
|
24
|
+
module BugBunnyRailsSpec
|
|
25
|
+
# La app: sin archivos de configuración propios, todo acá.
|
|
26
|
+
class Application < Rails::Application
|
|
27
|
+
config.root = __dir__
|
|
28
|
+
config.eager_load = false
|
|
29
|
+
config.logger = Logger.new(nil)
|
|
30
|
+
config.secret_key_base = 'bug_bunny-rails-spec'
|
|
31
|
+
end
|
|
32
|
+
|
|
33
|
+
# Lo que un mensaje deja por hilo: lo que los specs miran pasar (o no) al siguiente.
|
|
34
|
+
class LeftoverState < ActiveSupport::CurrentAttributes
|
|
35
|
+
attribute :value
|
|
36
|
+
end
|
|
37
|
+
|
|
38
|
+
# Contexto de traza, como el `ExisRay::Tracer` de ExisRay: un `CurrentAttributes`.
|
|
39
|
+
class TraceContext < ActiveSupport::CurrentAttributes
|
|
40
|
+
attribute :trace_id
|
|
41
|
+
end
|
|
42
|
+
|
|
43
|
+
# Un middleware que carga estado por hilo antes de procesar el mensaje y lo limpia al salir, como
|
|
44
|
+
# el de tracing de ExisRay. Se registra ANTES de que el Railtie de BugBunny registre el suyo: es el
|
|
45
|
+
# orden que hace falta para ver si el executor lo borra.
|
|
46
|
+
class TracingMiddleware < BugBunny::ConsumerMiddleware::Base
|
|
47
|
+
def call(delivery_info, properties, body)
|
|
48
|
+
TraceContext.trace_id = 'from-tracing'
|
|
49
|
+
@app.call(delivery_info, properties, body)
|
|
50
|
+
ensure
|
|
51
|
+
TraceContext.reset
|
|
52
|
+
end
|
|
53
|
+
end
|
|
54
|
+
end
|
|
55
|
+
|
|
56
|
+
unless ENV['BUG_BUNNY_SPEC_CONFIGURE'] == 'none'
|
|
57
|
+
BugBunny.configure do |config|
|
|
58
|
+
config.logger = Logger.new(nil)
|
|
59
|
+
# El `respond_to?` deja correr estos specs contra una versión de la gema sin la opción, para ver
|
|
60
|
+
# que fallan sin el cambio.
|
|
61
|
+
if config.respond_to?(:consumer_rails_executor=)
|
|
62
|
+
config.consumer_rails_executor = ENV['BUG_BUNNY_SPEC_EXECUTOR'] != 'off'
|
|
63
|
+
end
|
|
64
|
+
end
|
|
65
|
+
BugBunny.consumer_middlewares.use(BugBunnyRailsSpec::TracingMiddleware)
|
|
66
|
+
end
|
|
67
|
+
|
|
68
|
+
BugBunnyRailsSpec::Application.initialize!
|
|
69
|
+
|
|
70
|
+
puts BugBunny.consumer_middlewares.instance_variable_get(:@middlewares).map(&:name) if $PROGRAM_NAME == __FILE__
|
|
@@ -0,0 +1,165 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require_relative 'rails_helper'
|
|
4
|
+
require 'open3'
|
|
5
|
+
|
|
6
|
+
# Cada mensaje del Consumer corre dentro del executor de Rails (sequre/bug_bunny#70).
|
|
7
|
+
#
|
|
8
|
+
# Las entregas se procesan en un hilo propio, como el hilo de trabajo de Bunny: Rails no lo conoce.
|
|
9
|
+
RSpec.describe 'BugBunny::ConsumerMiddleware::RailsExecutor' do
|
|
10
|
+
let(:channel) do
|
|
11
|
+
double('channel').tap do |ch|
|
|
12
|
+
allow(ch).to receive(:ack)
|
|
13
|
+
allow(ch).to receive(:reject)
|
|
14
|
+
allow(ch).to receive(:open?).and_return(true)
|
|
15
|
+
end
|
|
16
|
+
end
|
|
17
|
+
|
|
18
|
+
let(:consumer) do
|
|
19
|
+
session = instance_double(BugBunny::Session, channel: channel, close: nil)
|
|
20
|
+
described_consumer = BugBunny::Consumer.new(double('connection'))
|
|
21
|
+
described_consumer.instance_variable_set(:@session, session)
|
|
22
|
+
described_consumer
|
|
23
|
+
end
|
|
24
|
+
|
|
25
|
+
let(:properties) do
|
|
26
|
+
double('properties', type: 'probe/show', headers: { 'x-http-method' => 'GET' },
|
|
27
|
+
correlation_id: 'corr-1', reply_to: nil, content_type: 'application/json')
|
|
28
|
+
end
|
|
29
|
+
|
|
30
|
+
# Lo que hace la acción del controller en cada entrega.
|
|
31
|
+
let(:on_message) { -> {} }
|
|
32
|
+
|
|
33
|
+
before do
|
|
34
|
+
allow(BugBunny.routes).to receive(:recognize)
|
|
35
|
+
.and_return({ controller: 'probe', action: 'show', params: {}, namespace: nil })
|
|
36
|
+
|
|
37
|
+
handler = on_message
|
|
38
|
+
stub_const('BugBunny::Controllers::ProbeController', Class.new(BugBunny::Controller) do
|
|
39
|
+
define_method(:show) do
|
|
40
|
+
handler.call
|
|
41
|
+
render status: 200, json: {}
|
|
42
|
+
end
|
|
43
|
+
end)
|
|
44
|
+
end
|
|
45
|
+
|
|
46
|
+
# Procesa las entregas en orden, en un hilo propio (como el de Bunny).
|
|
47
|
+
def deliver_on_a_bunny_like_thread(*tags)
|
|
48
|
+
Thread.new do
|
|
49
|
+
tags.each do |tag|
|
|
50
|
+
delivery_info = double('delivery_info', exchange: 'x', routing_key: 'probe', delivery_tag: tag,
|
|
51
|
+
redelivered?: false)
|
|
52
|
+
yield(:before, tag) if block_given?
|
|
53
|
+
consumer.send(:handle_delivery, delivery_info, properties, '{}')
|
|
54
|
+
yield(:after, tag) if block_given?
|
|
55
|
+
end
|
|
56
|
+
end.join
|
|
57
|
+
end
|
|
58
|
+
|
|
59
|
+
it 'queda primero en la cadena, antes del middleware de tracing registrado antes que él' do
|
|
60
|
+
middlewares = BugBunny.consumer_middlewares.instance_variable_get(:@middlewares).map(&:name)
|
|
61
|
+
|
|
62
|
+
expect(middlewares).to eq(%w[BugBunny::ConsumerMiddleware::RailsExecutor BugBunnyRailsSpec::TracingMiddleware])
|
|
63
|
+
end
|
|
64
|
+
|
|
65
|
+
describe 'el estado por hilo no pasa de un mensaje al siguiente' do
|
|
66
|
+
let(:seen) { [] }
|
|
67
|
+
let(:on_message) do
|
|
68
|
+
lambda do
|
|
69
|
+
seen << BugBunnyRailsSpec::LeftoverState.value
|
|
70
|
+
BugBunnyRailsSpec::LeftoverState.value = 'left by the previous message'
|
|
71
|
+
end
|
|
72
|
+
end
|
|
73
|
+
|
|
74
|
+
it 'el segundo mensaje arranca sin lo que el primero dejó en un CurrentAttributes' do
|
|
75
|
+
deliver_on_a_bunny_like_thread(1, 2)
|
|
76
|
+
|
|
77
|
+
expect(seen).to eq([nil, nil])
|
|
78
|
+
end
|
|
79
|
+
end
|
|
80
|
+
|
|
81
|
+
describe 'la conexión de ActiveRecord' do
|
|
82
|
+
# Si el hilo tiene una conexión tomada del pool (en Rails 8.1, `active_connection?` devuelve la
|
|
83
|
+
# conexión, o nil).
|
|
84
|
+
def connection_leased?
|
|
85
|
+
ActiveRecord::Base.connection_pool.active_connection?.present?
|
|
86
|
+
end
|
|
87
|
+
|
|
88
|
+
let(:inside) { [] }
|
|
89
|
+
let(:on_message) do
|
|
90
|
+
lambda do
|
|
91
|
+
ActiveRecord::Base.connection.execute('SELECT 1')
|
|
92
|
+
inside << connection_leased?
|
|
93
|
+
end
|
|
94
|
+
end
|
|
95
|
+
|
|
96
|
+
it 'vuelve al pool al terminar el mensaje que la usó' do
|
|
97
|
+
after = []
|
|
98
|
+
deliver_on_a_bunny_like_thread(1) do |moment, _tag|
|
|
99
|
+
after << connection_leased? if moment == :after
|
|
100
|
+
end
|
|
101
|
+
|
|
102
|
+
expect(inside).to eq([true]) # el mensaje la usó
|
|
103
|
+
expect(after).to eq([false]) # y al terminar ya no la tiene el hilo
|
|
104
|
+
end
|
|
105
|
+
end
|
|
106
|
+
|
|
107
|
+
describe 'un middleware que carga estado antes que el executor' do
|
|
108
|
+
let(:seen) { [] }
|
|
109
|
+
let(:on_message) { -> { seen << BugBunnyRailsSpec::TraceContext.trace_id } }
|
|
110
|
+
|
|
111
|
+
it 'conserva ese estado dentro del mensaje: el executor lo envuelve y no lo borra' do
|
|
112
|
+
deliver_on_a_bunny_like_thread(1)
|
|
113
|
+
|
|
114
|
+
expect(seen).to eq(['from-tracing'])
|
|
115
|
+
end
|
|
116
|
+
end
|
|
117
|
+
|
|
118
|
+
describe 'un error que escapa del procesamiento del mensaje' do
|
|
119
|
+
let(:reports) { [] }
|
|
120
|
+
let(:subscriber) do
|
|
121
|
+
collected = reports
|
|
122
|
+
Class.new do
|
|
123
|
+
define_method(:report) { |error, handled:, **| collected << [error.message, handled] }
|
|
124
|
+
end.new
|
|
125
|
+
end
|
|
126
|
+
|
|
127
|
+
before { Rails.error.subscribe(subscriber) }
|
|
128
|
+
after { Rails.error.unsubscribe(subscriber) if Rails.error.respond_to?(:unsubscribe) } # no existe en Rails 7.0
|
|
129
|
+
|
|
130
|
+
it 'termina en un reject sin requeue, como hoy, y además se reporta a Rails.error' do
|
|
131
|
+
allow(consumer).to receive(:process_message).and_raise(RuntimeError, 'boom')
|
|
132
|
+
|
|
133
|
+
deliver_on_a_bunny_like_thread(7)
|
|
134
|
+
|
|
135
|
+
expect(channel).to have_received(:reject).with(7, false)
|
|
136
|
+
expect(reports).to eq([['boom', false]])
|
|
137
|
+
end
|
|
138
|
+
end
|
|
139
|
+
|
|
140
|
+
describe 'config.consumer_rails_executor' do
|
|
141
|
+
# Rails se inicializa una vez por proceso: la app se bootea de nuevo en un subproceso.
|
|
142
|
+
# Las líneas de stdout que nombran un middleware: un warning del entorno no las rompe.
|
|
143
|
+
def middlewares_after_boot(env)
|
|
144
|
+
app = File.expand_path('app.rb', __dir__)
|
|
145
|
+
stdout, stderr, status = Open3.capture3(env, RbConfig.ruby, app)
|
|
146
|
+
raise "la app no booteó:\n#{stderr}" unless status.success?
|
|
147
|
+
|
|
148
|
+
stdout.lines.map(&:strip).grep(/\ABugBunny/)
|
|
149
|
+
end
|
|
150
|
+
|
|
151
|
+
it 'con false, no registra el middleware' do
|
|
152
|
+
expect(middlewares_after_boot('BUG_BUNNY_SPEC_EXECUTOR' => 'off')).to eq(['BugBunnyRailsSpec::TracingMiddleware'])
|
|
153
|
+
end
|
|
154
|
+
|
|
155
|
+
it 'con true, lo registra primero' do
|
|
156
|
+
expect(middlewares_after_boot('BUG_BUNNY_SPEC_EXECUTOR' => 'on'))
|
|
157
|
+
.to eq(%w[BugBunny::ConsumerMiddleware::RailsExecutor BugBunnyRailsSpec::TracingMiddleware])
|
|
158
|
+
end
|
|
159
|
+
|
|
160
|
+
it 'sin BugBunny.configure previo, bootea y lo registra: la opción ausente vale su default' do
|
|
161
|
+
expect(middlewares_after_boot('BUG_BUNNY_SPEC_CONFIGURE' => 'none'))
|
|
162
|
+
.to eq(['BugBunny::ConsumerMiddleware::RailsExecutor'])
|
|
163
|
+
end
|
|
164
|
+
end
|
|
165
|
+
end
|
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require_relative 'rails_helper'
|
|
4
|
+
require 'rails/generators'
|
|
5
|
+
require 'stringio'
|
|
6
|
+
require 'tmpdir'
|
|
7
|
+
require 'generators/bug_bunny/install/install_generator'
|
|
8
|
+
|
|
9
|
+
# El generador de instalación no escribe nada fuera de lo que la gema necesita: ni crea ni modifica
|
|
10
|
+
# el `CLAUDE.md` del repo que la usa (sequre/bug_bunny#72).
|
|
11
|
+
RSpec.describe BugBunny::Generators::InstallGenerator do
|
|
12
|
+
let(:template) { File.expand_path('../../lib/generators/bug_bunny/install/templates/initializer.rb', __dir__) }
|
|
13
|
+
|
|
14
|
+
# Corre el generador sobre `dir` y devuelve lo que imprimió.
|
|
15
|
+
def run_generator(dir)
|
|
16
|
+
output = StringIO.new
|
|
17
|
+
original_stdout = $stdout
|
|
18
|
+
$stdout = output
|
|
19
|
+
described_class.start([], destination_root: dir)
|
|
20
|
+
output.string
|
|
21
|
+
ensure
|
|
22
|
+
$stdout = original_stdout
|
|
23
|
+
end
|
|
24
|
+
|
|
25
|
+
around do |example|
|
|
26
|
+
Dir.mktmpdir('bug_bunny-generator') do |dir|
|
|
27
|
+
@dir = dir
|
|
28
|
+
example.run
|
|
29
|
+
end
|
|
30
|
+
end
|
|
31
|
+
|
|
32
|
+
let(:claude_md) { File.join(@dir, 'CLAUDE.md') }
|
|
33
|
+
|
|
34
|
+
it 'does not create CLAUDE.md' do
|
|
35
|
+
run_generator(@dir)
|
|
36
|
+
|
|
37
|
+
expect(File.exist?(claude_md)).to be(false)
|
|
38
|
+
end
|
|
39
|
+
|
|
40
|
+
it 'leaves an existing CLAUDE.md untouched' do
|
|
41
|
+
original = "# App\n\n## Gemas internas\n"
|
|
42
|
+
File.write(claude_md, original)
|
|
43
|
+
|
|
44
|
+
run_generator(@dir)
|
|
45
|
+
|
|
46
|
+
expect(File.read(claude_md)).to eq(original)
|
|
47
|
+
end
|
|
48
|
+
|
|
49
|
+
it 'still creates the initializer and the controllers directory' do
|
|
50
|
+
run_generator(@dir)
|
|
51
|
+
|
|
52
|
+
expect(File.read(File.join(@dir, 'config/initializers/bug_bunny.rb'))).to eq(File.read(template))
|
|
53
|
+
expect(File.exist?(File.join(@dir, 'app/bug_bunny/controllers/.keep'))).to be(true)
|
|
54
|
+
end
|
|
55
|
+
|
|
56
|
+
it 'does not mention CLAUDE.md nor bug_bunny:sync in its output' do
|
|
57
|
+
output = run_generator(@dir)
|
|
58
|
+
|
|
59
|
+
expect(output).not_to include('CLAUDE.md')
|
|
60
|
+
expect(output).not_to include('bug_bunny:sync')
|
|
61
|
+
end
|
|
62
|
+
|
|
63
|
+
it 'only runs the initializer and directories steps' do
|
|
64
|
+
expect(described_class.all_tasks.keys).to eq(%w[create_initializer create_directories])
|
|
65
|
+
end
|
|
66
|
+
end
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require_relative 'rails_helper'
|
|
4
|
+
require 'rake'
|
|
5
|
+
|
|
6
|
+
# El Railtie no registra tareas de rake: la que había, `bug_bunny:sync`, escribía el `CLAUDE.md` del repo
|
|
7
|
+
# que usa la gema (sequre/bug_bunny#72).
|
|
8
|
+
RSpec.describe 'BugBunny::Railtie rake tasks' do
|
|
9
|
+
before(:all) do
|
|
10
|
+
Rake.application = Rake::Application.new
|
|
11
|
+
Rails.application.load_tasks
|
|
12
|
+
end
|
|
13
|
+
|
|
14
|
+
it 'does not define bug_bunny:sync' do
|
|
15
|
+
expect(Rake::Task.task_defined?('bug_bunny:sync')).to be(false)
|
|
16
|
+
end
|
|
17
|
+
|
|
18
|
+
it 'loads the application tasks' do
|
|
19
|
+
expect(Rake::Task.task_defined?('environment')).to be(true)
|
|
20
|
+
end
|
|
21
|
+
end
|
|
@@ -188,6 +188,12 @@ RSpec.describe BugBunny::Configuration do
|
|
|
188
188
|
end
|
|
189
189
|
end
|
|
190
190
|
|
|
191
|
+
describe 'consumer_rails_executor flag' do
|
|
192
|
+
it 'tiene default true (el Railtie envuelve cada mensaje con el executor de Rails)' do
|
|
193
|
+
expect(BugBunny::Configuration.new.consumer_rails_executor).to be(true)
|
|
194
|
+
end
|
|
195
|
+
end
|
|
196
|
+
|
|
191
197
|
describe 'nack_raise flag' do
|
|
192
198
|
it 'tiene default true (raise PublishNacked en NACK)' do
|
|
193
199
|
expect(BugBunny::Configuration.new.nack_raise).to be(true)
|
|
@@ -47,6 +47,19 @@ RSpec.describe BugBunny::ConsumerMiddleware::Stack do
|
|
|
47
47
|
end
|
|
48
48
|
end
|
|
49
49
|
|
|
50
|
+
describe '#prepend' do
|
|
51
|
+
it 'registra el middleware al principio: envuelve a los ya registrados' do
|
|
52
|
+
log = []
|
|
53
|
+
stack.use(tracking_middleware(log, :a))
|
|
54
|
+
result = stack.prepend(tracking_middleware(log, :first))
|
|
55
|
+
|
|
56
|
+
stack.call(delivery_info, properties, body) { log << :core }
|
|
57
|
+
|
|
58
|
+
expect(result).to be(stack)
|
|
59
|
+
expect(log).to eq(%i[first_before a_before core a_after first_after])
|
|
60
|
+
end
|
|
61
|
+
end
|
|
62
|
+
|
|
50
63
|
describe '#empty?' do
|
|
51
64
|
it 'retorna true cuando no hay middlewares' do
|
|
52
65
|
expect(stack.empty?).to be(true)
|
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require 'spec_helper'
|
|
4
|
+
|
|
5
|
+
# Fuera de Rails la gema se comporta como antes de sequre/bug_bunny#70: el middleware del executor
|
|
6
|
+
# lo registra el Railtie, y el Railtie no se carga.
|
|
7
|
+
RSpec.describe 'BugBunny fuera de Rails' do
|
|
8
|
+
it 'no carga el Railtie' do
|
|
9
|
+
expect(defined?(Rails)).to be_nil
|
|
10
|
+
expect(defined?(BugBunny::Railtie)).to be_nil
|
|
11
|
+
end
|
|
12
|
+
|
|
13
|
+
it 'no carga el middleware del executor ni lo pone en la cadena del Consumer' do
|
|
14
|
+
middlewares = BugBunny.consumer_middlewares.instance_variable_get(:@middlewares).map(&:name)
|
|
15
|
+
|
|
16
|
+
expect(defined?(BugBunny::ConsumerMiddleware::RailsExecutor)).to be_nil
|
|
17
|
+
expect(middlewares).not_to include('BugBunny::ConsumerMiddleware::RailsExecutor')
|
|
18
|
+
end
|
|
19
|
+
end
|