bug_bunny 4.1.1 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 599004cdcb498ca746612f60202301ce9783a67ac37d14ecd4c29f51ccaf48bb
-  data.tar.gz: f748ba9a55e91f96a5571f671afa524f7e330cceede0f12c5c7cef6d25d2d2ff
+  metadata.gz: 26437c12bdcd679124739cffc4d1c9769587bc6ffd241d6a03a75880c3bd910d
+  data.tar.gz: cc185721833cbf505d1fe44ac1dac7ac496fda1677b54898ce950a1d1badff68
 SHA512:
-  metadata.gz: 7df1503a55cb62d9f87168a84b8e92fe773b4c9525b143d6f848227e66fe63e5ab75f6191a408b00bb9c8840b44c0f8fdbc36cd0a8d2eb56e02018d09654d269
-  data.tar.gz: d5433d839c45ad95a2d0399535ff629112458e90d0e4e1ec89f97afa450b139bcb7855c64c27042c22bce0bde87b2bfa7bd6f8bae5b879dd7eb0c71ff1d20d3c
+  metadata.gz: 71da0a97f33b38263957a878350e8a2daa935a0f211e0fa59af589b507a7d11635e84ac6170ee2a4fafb16b0c4f8ddeec61b388f38d7f9856d171e3059b004f3
+  data.tar.gz: 962de8a788d263c04cf0d9fa5da2e6c3a5ec3a2d6156b80ff542b8d2fd333c4d9d0915f94775f8fb9c8101d507691cf757701904fe1d0477d5dabfcd006efa7e

data/CHANGELOG.md

@@ -1,15 +1,28 @@
 # Changelog
 
-## [4.1.1] - 2026-03-22
+## [4.2.0] - 2026-03-22
 
-### 🐛 Bug Fixes
-* **Consumer:** Previene memory leak al detener el `TimerTask` de health check previo antes de realizar una reconexión.
-* **Controller:** Corrige la mutación accidental de \`log_tags\` globales al usar una lógica de herencia no destructiva en \`compute_tags\`.
+### 🔠 Observability & Structured Logging
+* **Structured Logs (Key-Value):** Se migraron todos los logs del framework a un formato \`key=value\` estructurado, ideal para herramientas de monitoreo como Datadog o CloudWatch. Se eliminaron emojis y texto libre para mejorar el parseo automático.
+* **Lazy Evaluation (Debug Blocks):** Las llamadas a \`logger.debug\` ahora utilizan bloques para evitar la interpolación de strings innecesaria en producción, optimizando el uso de CPU y memoria.
+
+### ðŸ›¡ï¸  Resilience & Connectivity
+* **Exponential Backoff:** El \`Consumer\` ahora implementa un algoritmo de reintento exponencial para reconectarse a RabbitMQ, evitando picos de carga durante caídas del broker.
+* **Max Reconnect Attempts:** Nueva configuración \`max_reconnect_attempts\` que permite que el worker falle definitivamente tras N intentos, facilitando el reinicio del Pod por parte de orquestadores como Kubernetes.
+* **Performance Tuning:** Se desactivaron los \`publisher_confirms\` en el canal del \`Consumer\` al responder RPCs para reducir la latencia de respuesta (round-trips innecesarios).
+
+## [4.1.2] - 2026-03-22
 
 ### ✨ Improvements
 * **Controller:** Ahora lanza una excepción \`BugBunny::BadRequest\` (400) si el cuerpo de la petición contiene un JSON inválido, mejorando la depuración en el cliente.
 * **Resource:** Se añadió una protección a \`.with\` (\`ScopeProxy\`) para asegurar que el contexto sea de un solo uso, evitando efectos secundarios en llamadas encadenadas.
 
+## [4.1.1] - 2026-03-22
+
+### 🐛 Bug Fixes
+* **Consumer:** Previene memory leak al detener el `TimerTask` de health check previo antes de realizar una reconexión.
+* **Controller:** Corrige la mutación accidental de \`log_tags\` globales al usar una lógica de herencia no destructiva en \`compute_tags\`.
+
 ## [4.1.0] - 2026-03-22
 
 ### 🚀 New Features & Improvements

data/README.md

@@ -74,7 +74,9 @@ BugBunny.configure do |config|
 
   # 2. Timeouts y Recuperación
   config.rpc_timeout = 10               # Segundos máx para esperar respuesta (Síncrono)
-  config.network_recovery_interval = 5  # Reintento de conexión
+  config.network_recovery_interval = 5  # Base del backoff de reconexión (segundos)
+  config.max_reconnect_interval    = 60 # Techo del backoff exponencial (segundos)
+  config.max_reconnect_attempts    = nil # nil = reintenta infinitamente; Integer = falla hard
 
   # 3. Health Checks (Opcional, para Docker Swarm / K8s)
   config.health_check_file = '/tmp/bug_bunny_health'
@@ -420,6 +422,30 @@ Para máxima velocidad, BugBunny usa `amq.rabbitmq.reply-to`.
 ### Seguridad
 El Router incluye protecciones contra **Remote Code Execution (RCE)**. El Consumer verifica estrictamente que el Controlador resuelto a través del archivo de rutas herede de `BugBunny::Controller` antes de ejecutarla, impidiendo la inyección de clases arbitrarias. Además, las llamadas a rutas no registradas fallan rápido con un `404 Not Found`.
 
+### Reconexión con Backoff Exponencial
+
+Cuando el Consumer pierde la conexión a RabbitMQ, reintenta automáticamente usando un backoff exponencial basado en `network_recovery_interval`:
+
+| Intento | Espera (base = 5s, techo = 60s) |
+|---------|----------------------------------|
+| 1       | 5s                               |
+| 2       | 10s                              |
+| 3       | 20s                              |
+| 4       | 40s                              |
+| 5+      | 60s (cap)                        |
+
+Por defecto reintenta indefinidamente (`max_reconnect_attempts: nil`). En entornos orquestados (Kubernetes, Docker Swarm), es preferible dejar que el orquestador reinicie el contenedor cuando la infraestructura no está disponible:
+
+```ruby
+BugBunny.configure do |config|
+  config.network_recovery_interval = 5   # Base del backoff
+  config.max_reconnect_interval    = 60  # Techo máximo de espera
+  config.max_reconnect_attempts    = 10  # Falla hard después de 10 intentos
+end
+```
+
+Con esta configuración, si RabbitMQ no vuelve en ~10 reintentos el proceso levanta la excepción y el orquestador lo reinicia con su propia política de restart.
+
 ### Health Checks en Docker Swarm / Kubernetes
 Dado que un Worker se ejecuta en segundo plano sin exponer un servidor web tradicional, orquestadores como Docker Swarm o Kubernetes no pueden usar un endpoint HTTP para verificar si el proceso está saludable.
 

data/lib/bug_bunny/configuration.rb

@@ -38,9 +38,16 @@ module BugBunny
     # @return [Boolean] Si `true`, Bunny intentará reconectar automáticamente.
     attr_accessor :automatically_recover
 
-    # @return [Integer] Tiempo en segundos a esperar antes de intentar reconectar.
+    # @return [Integer] Tiempo en segundos a esperar antes de intentar reconectar (base del backoff).
     attr_accessor :network_recovery_interval
 
+    # @return [Integer, nil] Número máximo de intentos de reconexión del Consumer antes de rendirse.
+    #   Si es `nil` (default), reintenta indefinidamente.
+    attr_accessor :max_reconnect_attempts
+
+    # @return [Integer] Techo en segundos para el backoff exponencial de reconexión (default: 60).
+    attr_accessor :max_reconnect_interval
+
     # @return [Integer] Timeout en segundos para establecer la conexión TCP inicial.
     attr_accessor :connection_timeout
 
@@ -106,6 +113,8 @@ module BugBunny
       @bunny_logger.level = Logger::WARN
       @automatically_recover = true
       @network_recovery_interval = 5
+      @max_reconnect_attempts = nil
+      @max_reconnect_interval = 60
       @connection_timeout = 10
       @read_timeout = 30
       @write_timeout = 30

data/lib/bug_bunny/consumer.rb

@@ -43,7 +43,7 @@ module BugBunny
     #
     # @param connection [Bunny::Session] Conexión nativa de Bunny.
     def initialize(connection)
-      @session = BugBunny::Session.new(connection)
+      @session = BugBunny::Session.new(connection, publisher_confirms: false)
       @health_timer = nil
     end
 
@@ -61,41 +61,58 @@ module BugBunny
     # @param block [Boolean] Si es `true`, bloquea el hilo actual (loop infinito).
     # @return [void]
     def subscribe(queue_name:, exchange_name:, routing_key:, exchange_type: 'direct', exchange_opts: {}, queue_opts: {}, block: true)
-      # Declaración de Infraestructura
-      x = session.exchange(name: exchange_name, type: exchange_type, opts: exchange_opts)
-      q = session.queue(queue_name, queue_opts)
-      q.bind(x, routing_key: routing_key)
-
-      # 📊 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(exchange_opts || {})
-      final_q_opts = BugBunny::Session::DEFAULT_QUEUE_OPTIONS
-                       .merge(BugBunny.configuration.queue_options || {})
-                       .merge(queue_opts || {})
-
-      BugBunny.configuration.logger.info("[BugBunny::Consumer] 🎧 Listening on '#{queue_name}' (Opts: #{final_q_opts})")
-      BugBunny.configuration.logger.info("[BugBunny::Consumer] 🔀 Bounded to Exchange '#{exchange_name}' (#{exchange_type}) | Opts: #{final_x_opts} | RK: '#{routing_key}'")
-
-      start_health_check(queue_name)
-
-      q.subscribe(manual_ack: true, block: block) do |delivery_info, properties, body|
-        trace_id = properties.correlation_id
-
-        logger = BugBunny.configuration.logger
-
-        if logger.respond_to?(:tagged)
-          logger.tagged(trace_id) { process_message(delivery_info, properties, body) }
-        elsif defined?(Rails) && Rails.logger.respond_to?(:tagged)
-          Rails.logger.tagged(trace_id) { process_message(delivery_info, properties, body) }
-        else
-          process_message(delivery_info, properties, body)
+      attempt = 0
+
+      begin
+        # Declaración de Infraestructura
+        x = session.exchange(name: exchange_name, type: exchange_type, opts: exchange_opts)
+        q = session.queue(queue_name, queue_opts)
+        q.bind(x, routing_key: routing_key)
+
+        # 📊 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(exchange_opts || {})
+        final_q_opts = BugBunny::Session::DEFAULT_QUEUE_OPTIONS
+                         .merge(BugBunny.configuration.queue_options || {})
+                         .merge(queue_opts || {})
+
+        BugBunny.configuration.logger.info("component=bug_bunny event=consumer_start queue=#{queue_name} queue_opts=#{final_q_opts}")
+        BugBunny.configuration.logger.info("component=bug_bunny event=consumer_bound exchange=#{exchange_name} exchange_type=#{exchange_type} routing_key=#{routing_key} exchange_opts=#{final_x_opts}")
+
+        start_health_check(queue_name)
+
+        q.subscribe(manual_ack: true, block: block) do |delivery_info, properties, body|
+          trace_id = properties.correlation_id
+
+          logger = BugBunny.configuration.logger
+
+          if logger.respond_to?(:tagged)
+            logger.tagged(trace_id) { process_message(delivery_info, properties, body) }
+          elsif defined?(Rails) && Rails.logger.respond_to?(:tagged)
+            Rails.logger.tagged(trace_id) { process_message(delivery_info, properties, body) }
+          else
+            process_message(delivery_info, properties, body)
+          end
+        end
+      rescue StandardError => e
+        attempt += 1
+        max_attempts = BugBunny.configuration.max_reconnect_attempts
+
+        if max_attempts && attempt >= max_attempts
+          BugBunny.configuration.logger.error { "component=bug_bunny event=reconnect_exhausted attempts=#{max_attempts} error=#{e.message.inspect}" }
+          raise
         end
+
+        wait = [
+          BugBunny.configuration.network_recovery_interval * (2 ** (attempt - 1)),
+          BugBunny.configuration.max_reconnect_interval
+        ].min
+
+        BugBunny.configuration.logger.error { "component=bug_bunny event=connection_error error=#{e.message.inspect} attempt=#{attempt} max_attempts=#{max_attempts || 'infinity'} retry_in=#{wait}" }
+        sleep wait
+        retry
       end
-    rescue StandardError => e
-      BugBunny.configuration.logger.error("[BugBunny::Consumer] 💥 Connection Error: #{e.message}. Retrying in #{BugBunny.configuration.network_recovery_interval}s...")
-      sleep BugBunny.configuration.network_recovery_interval
-      retry
     end
 
     private
@@ -113,7 +130,7 @@ module BugBunny
       path = properties.type || (properties.headers && properties.headers['path'])
 
       if path.nil? || path.empty?
-        BugBunny.configuration.logger.error("[BugBunny::Consumer] ⛔ Rejected: Missing 'type' header.")
+        BugBunny.configuration.logger.error('component=bug_bunny event=message_rejected reason=missing_type_header')
         session.channel.reject(delivery_info.delivery_tag, false)
         return
       end
@@ -122,8 +139,8 @@ module BugBunny
       headers_hash = properties.headers || {}
       http_method = (headers_hash['x-http-method'] || headers_hash['method'] || 'GET').to_s.upcase
 
-      BugBunny.configuration.logger.info("[BugBunny::Consumer] 📥 Received #{http_method} \"/#{path}\" | RK: '#{delivery_info.routing_key}'")
-      BugBunny.configuration.logger.debug("[BugBunny::Consumer] 📦 Body: #{body.truncate(200)}")
+      BugBunny.configuration.logger.info("component=bug_bunny event=message_received method=#{http_method} path=#{path} routing_key=#{delivery_info.routing_key}")
+      BugBunny.configuration.logger.debug { "component=bug_bunny event=message_received_body body=#{body.truncate(200).inspect}" }
 
       # ===================================================================
       # 3. Ruteo Declarativo
@@ -140,7 +157,7 @@ module BugBunny
       route_info = BugBunny.routes.recognize(http_method, uri.path)
 
       if route_info.nil?
-        BugBunny.configuration.logger.warn("[BugBunny::Consumer] ⚠️  No route matches [#{http_method}] \"/#{uri.path}\"")
+        BugBunny.configuration.logger.warn("component=bug_bunny event=route_not_found method=#{http_method} path=#{uri.path}")
         handle_fatal_error(properties, 404, "Not Found", "No route matches [#{http_method}] \"/#{uri.path}\"")
         session.channel.reject(delivery_info.delivery_tag, false)
         return
@@ -159,7 +176,7 @@ module BugBunny
       begin
         controller_class = controller_class_name.constantize
       rescue NameError
-        BugBunny.configuration.logger.warn("[BugBunny::Consumer] ⚠️  Controller class not found: #{controller_class_name}")
+        BugBunny.configuration.logger.warn("component=bug_bunny event=controller_not_found controller=#{controller_class_name}")
         handle_fatal_error(properties, 404, "Not Found", "Controller #{controller_class_name} not found")
         session.channel.reject(delivery_info.delivery_tag, false)
         return
@@ -167,13 +184,13 @@ module BugBunny
 
       # Verificación estricta de Seguridad (RCE Prevention)
       unless controller_class < BugBunny::Controller
-        BugBunny.configuration.logger.error("[BugBunny::Consumer] ⛔ Security Alert: #{controller_class} is not a valid BugBunny Controller")
+        BugBunny.configuration.logger.error("component=bug_bunny event=security_violation reason=invalid_controller controller=#{controller_class}")
         handle_fatal_error(properties, 403, "Forbidden", "Invalid Controller Class")
         session.channel.reject(delivery_info.delivery_tag, false)
         return
       end
 
-      BugBunny.configuration.logger.debug("[BugBunny::Consumer] 🎯 Routed to #{controller_class_name}##{route_info[:action]}")
+      BugBunny.configuration.logger.debug { "component=bug_bunny event=route_matched controller=#{controller_class_name} action=#{route_info[:action]}" }
 
       request_metadata = {
         type: path,
@@ -199,8 +216,8 @@ module BugBunny
       session.channel.ack(delivery_info.delivery_tag)
 
     rescue StandardError => e
-      BugBunny.configuration.logger.error("[BugBunny::Consumer] 💥 Execution Error (#{e.class}): #{e.message}")
-      BugBunny.configuration.logger.debug(e.backtrace.join("\n"))
+      BugBunny.configuration.logger.error { "component=bug_bunny event=execution_error error_class=#{e.class} error=#{e.message.inspect}" }
+      BugBunny.configuration.logger.debug { "component=bug_bunny event=execution_error backtrace=#{e.backtrace.first(5).join(' | ').inspect}" }
       handle_fatal_error(properties, 500, "Internal Server Error", e.message)
       session.channel.reject(delivery_info.delivery_tag, false)
     end
@@ -212,7 +229,7 @@ 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)
-      BugBunny.configuration.logger.debug("[BugBunny::Consumer] 📤 Sending RPC Reply to #{reply_to} | ID: #{correlation_id}")
+      BugBunny.configuration.logger.debug { "component=bug_bunny event=rpc_reply reply_to=#{reply_to} correlation_id=#{correlation_id}" }
       session.channel.default_exchange.publish(
         payload.to_json,
         routing_key: reply_to,
@@ -261,7 +278,7 @@ module BugBunny
         # 2. Si llegamos aquí, RabbitMQ y la cola están vivos. Avisamos al orquestador actualizando el archivo.
         touch_health_file(file_path) if file_path
       rescue StandardError => e
-        BugBunny.configuration.logger.warn("[BugBunny::Consumer] ⚠️  Queue check failed: #{e.message}. Reconnecting session...")
+        BugBunny.configuration.logger.warn("component=bug_bunny event=health_check_failed queue=#{q_name} error=#{e.message.inspect}")
         session.close
       end
       @health_timer.execute
@@ -276,7 +293,7 @@ module BugBunny
     def touch_health_file(file_path)
       FileUtils.touch(file_path)
     rescue StandardError => e
-      BugBunny.configuration.logger.error("[BugBunny::Consumer] ⚠️  Cannot touch health check file '#{file_path}': #{e.message}")
+      BugBunny.configuration.logger.error("component=bug_bunny event=health_check_file_error path=#{file_path} error=#{e.message.inspect}")
     end
   end
 end

data/lib/bug_bunny/controller.rb

@@ -204,8 +204,8 @@ module BugBunny
       end
 
       # Fallback genérico si la excepción no fue mapeada
-      BugBunny.configuration.logger.error("[BugBunny::Controller] 💥 Unhandled Exception (#{exception.class}): #{exception.message}")
-      BugBunny.configuration.logger.error(exception.backtrace.first(5).join("\n"))
+      BugBunny.configuration.logger.error { "component=bug_bunny event=unhandled_exception error_class=#{exception.class} error=#{exception.message.inspect}" }
+      BugBunny.configuration.logger.error { "component=bug_bunny event=unhandled_exception backtrace=#{exception.backtrace.first(5).join(' | ').inspect}" }
 
       {
         status: 500,

data/lib/bug_bunny/producer.rb

@@ -73,7 +73,7 @@ module BugBunny
       begin
         fire(request)
 
-        BugBunny.configuration.logger.debug("[BugBunny::Producer] ⏳ Waiting for RPC response | ID: #{cid} | Timeout: #{wait_timeout}s")
+        BugBunny.configuration.logger.debug { "component=bug_bunny event=rpc_waiting correlation_id=#{cid} timeout=#{wait_timeout}" }
 
         # Bloqueamos el hilo aquí hasta que llegue la respuesta o expire el timeout
         response_payload = future.value(wait_timeout)
@@ -106,12 +106,9 @@ module BugBunny
                        .merge(BugBunny.configuration.exchange_options || {})
                        .merge(request.exchange_options || {})
 
-      # INFO: Resumen de una línea (Traffic)
-      BugBunny.configuration.logger.info("[BugBunny::Producer] 📤 #{verb} /#{target} | RK: '#{rk}' | ID: #{id}")
-
-      # DEBUG: Detalle completo de Infraestructura y Payload
-      BugBunny.configuration.logger.debug("[BugBunny::Producer] ⚙️ Exchange #{request.exchange} | Opts: #{final_x_opts}")
-      BugBunny.configuration.logger.debug("[BugBunny::Producer] 📦 Payload: #{payload.truncate(300)}") if payload.is_a?(String)
+      BugBunny.configuration.logger.info("component=bug_bunny event=publish method=#{verb} path=#{target} routing_key=#{rk} correlation_id=#{id}")
+      BugBunny.configuration.logger.debug { "component=bug_bunny event=publish_detail exchange=#{request.exchange} exchange_opts=#{final_x_opts}" }
+      BugBunny.configuration.logger.debug { "component=bug_bunny event=publish_payload payload=#{payload.truncate(300).inspect}" } if payload.is_a?(String)
     end
 
     # Serializa el mensaje para su transporte.
@@ -145,16 +142,16 @@ module BugBunny
       @reply_listener_mutex.synchronize do
         return if @reply_listener_started
 
-        BugBunny.configuration.logger.debug("[BugBunny::Producer] 👂 Starting Reply Listener on 'amq.rabbitmq.reply-to'")
+        BugBunny.configuration.logger.debug { 'component=bug_bunny event=reply_listener_start queue=amq.rabbitmq.reply-to' }
 
         # Consumimos sin ack (auto-ack) porque reply-to no soporta acks manuales de forma estándar
         @session.channel.basic_consume('amq.rabbitmq.reply-to', '', true, false, nil) do |_, props, body|
           cid = props.correlation_id.to_s
-          BugBunny.configuration.logger.debug("[BugBunny::Producer] 📥 RPC Response matched | ID: #{cid}")
+          BugBunny.configuration.logger.debug { "component=bug_bunny event=rpc_response_received correlation_id=#{cid}" }
           if (future = @pending_requests[cid])
             future.set(body)
           else
-            BugBunny.configuration.logger.warn("[BugBunny::Producer] ⚠️ Orphaned RPC Response received | ID: #{cid}")
+            BugBunny.configuration.logger.warn("component=bug_bunny event=rpc_response_orphaned correlation_id=#{cid}")
           end
         end
         @reply_listener_started = true

data/lib/bug_bunny/session.rb

@@ -24,8 +24,12 @@ module BugBunny
     # Inicializa una nueva sesión sin abrir canales todavía.
     #
     # @param connection [Bunny::Session] Una conexión (puede estar abierta o cerrada temporalmente).
-    def initialize(connection)
+    # @param publisher_confirms [Boolean] Si es `true`, el canal se abre en modo Publisher Confirms.
+    #   Activar solo en sesiones de Producer. En sesiones de Consumer genera overhead innecesario
+    #   ya que los replies RPC son fire-and-forget desde la perspectiva del servidor.
+    def initialize(connection, publisher_confirms: true)
       @connection = connection
+      @publisher_confirms = publisher_confirms
       @channel = nil
     end
 
@@ -105,8 +109,7 @@ module BugBunny
     def create_channel!
       @channel = @connection.create_channel
 
-      # Configuraciones globales de BugBunny
-      @channel.confirm_select
+      @channel.confirm_select if @publisher_confirms
 
       if BugBunny.configuration.channel_prefetch
         @channel.prefetch(BugBunny.configuration.channel_prefetch)
@@ -122,10 +125,10 @@ module BugBunny
     def ensure_connection!
       return if @connection.open?
 
-      BugBunny.configuration.logger.warn("[BugBunny::Session] ⚠️  Connection lost. Attempting to reconnect...")
+      BugBunny.configuration.logger.warn('component=bug_bunny event=reconnect_attempt')
       @connection.start
     rescue StandardError => e
-      BugBunny.configuration.logger.error("[BugBunny::Session] ❌ Critical connection failure: #{e.message}")
+      BugBunny.configuration.logger.error { "component=bug_bunny event=reconnect_failed error=#{e.message.inspect}" }
       raise BugBunny::CommunicationError, "Could not reconnect to RabbitMQ: #{e.message}"
     end
   end

data/lib/bug_bunny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BugBunny
-  VERSION = "4.1.1"
+  VERSION = "4.2.0"
 end

data/lib/bug_bunny.rb

@@ -83,7 +83,7 @@ module BugBunny
 
     @global_connection.close if @global_connection.open?
     @global_connection = nil
-    configuration.logger.info('[BugBunny] 🔌 Global connection closed.')
+    configuration.logger.info('component=bug_bunny event=disconnect')
   end
 
   # @api private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 4.1.1
+  version: 4.2.0
 platform: ruby
 authors:
 - gabix