bug_bunny 1.0.1 → 2.0.0

data/lib/bug_bunny/rabbit.rb

@@ -1,108 +1,308 @@
+# host: Especifica la dirección de red (hostname o IP) donde se está ejecutando el servidor RabbitMQ.
+# username: El nombre de usuario que se utiliza para la autenticación.
+# password: La contraseña para la autenticación.
+# vhost: Define el Virtual Host (VHost) al que se conectará la aplicación. Un VHost actúa como un namespace virtual dentro del broker, aislando entornos y recursos.
+# logger: Indica a Bunny que use el sistema de logging estándar de Rails, integrando los mensajes del cliente AMQP con el resto de los logs de tu aplicación.
+#
+# Resiliencia y Recuperación Automática
+#
+# Estos parámetros son fundamentales para manejar fallos de red y garantizar que la aplicación se recupere sin intervención manual.
+# automatically_recover: Indica al cliente Bunny que debe intentar automáticamente reestablecer la conexión y todos los recursos asociados (canales, colas, exchanges) si la conexión se pierde debido a un fallo de red o un reinicio del broker. Nota: Este parámetro puede entrar en conflicto con un bucle de retry manual).
+# network_recovery_interval: El tiempo que Bunny esperará entre intentos consecutivos de reconexión de red.
+# heartbeat: El intervalo de tiempo (en segundos) en el que el cliente y el servidor deben enviarse un pequeño paquete ("latido"). Si no se recibe un heartbeat durante dos intervalos consecutivos, se asume que la conexión ha muerto (generalmente por un fallo de red o un proceso colgado), lo que dispara el mecanismo de recuperación.
+#
+# Tiempos de Espera (Timeouts)
+#
+# Estos parámetros previenen que la aplicación se bloquee indefinidamente esperando una respuesta del servidor.
+# connection_timeout: Tiempo máximo (en segundos) que Bunny esperará para establecer la conexión TCP inicial con el servidor RabbitMQ.
+# read_timeout: Tiempo máximo (en segundos) que la conexión esperará para leer datos del socket. Si el servidor se queda en silencio por más de 30 segundos, el socket se cerrará.
+# write_timeout: Tiempo máximo (en segundos) que la conexión esperará para escribir datos en el socket. Útil para manejar escenarios donde la red es lenta o está congestionada.
+# continuation_timeout: Es un timeout interno de protocolo AMQP (dado en milisegundos). Define cuánto tiempo esperará el cliente para que el servidor responda a una operación que requiere múltiples frames o pasos (como una transacción o una confirmación compleja). En este caso, son 15 segundos.
 module BugBunny
   class Rabbit
-    require 'bunny'
-
-    attr_accessor :exchange,
-                  :rabbit_channel,
-                  :confirm_select,
-                  :no_ack,
-                  :persistent,
-                  :block,
-                  :logger,
-                  :identifier,
-                  :connection
-
-    def initialize(attrs = {})
-      @block          = attrs[:block] || true
-      @no_ack         = attrs[:no_ack] || true
-      @persistent     = attrs[:persistent] || true
-      @confirm_select = attrs[:confirm_select] || true
-      @logger         = attrs[:logger] || Logger.new('./log/bug_rabbit.log', 'monthly')
-      @identifier = SecureRandom.uuid
-
-      create_connection
-      set_channel
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    DEFAULT_EXCHANGE_OPTIONS = { durable: false, auto_delete: false }.freeze
+
+    # DEFAULT_MAX_PRIORITY = 10
+
+    DEFAULT_QUEUE_OPTIONS = {
+      exclusive: false,
+      durable: false,
+      auto_delete: true,
+      # arguments: { 'x-max-priority' => DEFAULT_MAX_PRIORITY }
+    }.freeze
+
+    attr_accessor :connection, :queue, :exchange
+
+    def channel
+      @channel_mutex ||= Mutex.new
+      return @channel if @channel&.open?
+
+      @channel_mutex.synchronize do
+        return @channel if @channel&.open?
+
+        @channel = connection.create_channel
+        @channel.confirm_select
+        @channel.prefetch(RABBIT_CHANNEL_PREFETCH) # Limita mensajes concurrentes por consumidor
+        @channel
+      end
+    end
+
+    def build_exchange(name: nil, type: 'direct', opts: {})
+      return @exchange if defined?(@exchange)
+
+      exchange_options = DEFAULT_EXCHANGE_OPTIONS.merge(opts.compact)
+
+      if name.blank?
+        @exchange = channel.default_exchange
+        return @exchange
+      end
+
+      Rails.logger.info("ExchangeName: #{name}, ExchangeType: #{type}, opts: #{opts}")
+
+      @exchange = case type.to_sym
+                  when :topic
+                    channel.topic(name, exchange_options)
+                  when :direct
+                    channel.direct(name, exchange_options)
+                  when :fanout
+                    channel.fanout(name, exchange_options)
+                  when :headers
+                    channel.headers(name, exchange_options)
+                  end
     end
 
-    def set_channel
-      logger.debug("Set Channel: #{connection.status}") if logger
-      try(:close_channel)
-      @rabbit_channel = connection.create_channel
-      @exchange = channel.default_exchange
-      channel.confirm_select if confirm_select
-      @rabbit_channel
+    def default_publish_options
+      @default_publish_opts ||= {
+        persistent: false,
+        app_id: Rails.application.class.module_parent_name
+      }.freeze
+
+      # Solo generamos valores dinámicos por llamada
+      @default_publish_opts.merge(
+        timestamp: Time.current.to_i,
+        correlation_id: SecureRandom.uuid
+      )
     end
 
-    def channel
-      open? ? @rabbit_channel : set_channel
+    def build_queue(name: '', opts: {})
+      name = name.to_s
+      queue_options = DEFAULT_QUEUE_OPTIONS.merge(opts.compact)
+      Rails.logger.info("QueueName: #{name}, opts: #{queue_options}")
+      @queue = channel.queue(name, queue_options)
     end
 
-    def close
-      @rabbit_channel.close if defined?(@rabbit_channel)
-      connection.close if connection.present?
-    rescue Bunny::ChannelAlreadyClosed
-      nil
+    def publish!(msg, opts)
+      options = default_publish_options.merge(opts.compact)
+
+      msg = msg.instance_of?(Hash) ? msg.to_json : msg.to_s
+
+      Rails.logger.info("Message: #{msg}")
+      Rails.logger.info("Options: #{options}")
+
+      exchange.publish(msg, options)
+      # channel.wait_for_confirms # Esto solo confirma que el mensaje llego el exchange
+    rescue Bunny::Exception => e
+      Rails.logger.error(e)
+      raise BugBunny::PublishError, e
     end
 
-    def close_channel
-      @rabbit_channel.close if defined?(@rabbit_channel)
+    def publish_and_consume!(msg, opts)
+      options = default_publish_options.merge(opts.compact)
+
+      response_latch = Concurrent::CountDownLatch.new(1)
+      response = nil
+
+      reply_queue = channel.queue('', exclusive: true, durable: false, auto_delete: true)
+      options[:reply_to] = reply_queue.name
+
+      subscription = reply_queue.subscribe(manual_ack: true, block: false) do |delivery_info, properties, body|
+        Rails.logger.debug("CONSUMER DeliveryInfo: #{delivery_info}")
+        Rails.logger.debug("CONSUMER Properties: #{properties}")
+        Rails.logger.debug("CONSUMER Body: #{body}")
+        if properties.correlation_id == options[:correlation_id]
+          response = ActiveSupport::JSON.decode(body).deep_symbolize_keys.with_indifferent_access
+          channel.ack(delivery_info.delivery_tag)
+          response_latch.count_down
+        else
+          Rails.logger.debug('Correlation_id not match')
+          # Si el correlation_id no coincide, rechazamos el mensaje para que RabbitMQ lo maneje
+          channel.reject(delivery_info.delivery_tag, false)
+        end
+      end
+
+      Rails.logger.debug("PUBLISHER Message: #{msg}")
+      Rails.logger.debug("PUBLISHER Options: #{options}")
+      publish!(msg, options)
+
+      if response_latch.wait(RABBIT_READ_TIMEOUT)
+        subscription.cancel
+        build_response(status: response[:status], body: response[:body])
+      else
+        raise "Timeout: No response received within #{RABBIT_READ_TIMEOUT} seconds."
+      end
+    rescue BugBunny::ResponseError::Base => e
+      subscription&.cancel
+      raise e
+    rescue RuntimeError => e
+      subscription&.cancel
+      Rails.logger.error("[Rabbit] Error in publish_and_consume: #{e.class} - <#{e.message}>")
+      raise(BugBunny::ResponseError::RequestTimeout, e.message) if e.message.include?('Timeout')
+
+      raise BugBunny::ResponseError::InternalServerError, e.message
+    rescue StandardError => e
+      subscription&.cancel
+      Rails.logger.error("[Rabbit] Error in publish_and_consume: #{e.class} - <#{e.message}>")
+      raise e
     end
 
-    def status
-      {
-        connection: connection.status,
-        channel: @rabbit_channel.status,
-        identifier: identifier
-      }
+    def parse_route(route)
+      # De momento no resuelve anidado
+      segments = route.split('/')
+      controller_name = segments[0]
+      action_name = 'index'
+      id = nil
+
+      case segments.length
+      when 2
+        # Patrón: controller/action (Ej: 'secrets/index', 'swarm/info')
+        action_name = segments[1]
+      when 3
+        # Patrón: controller/id/action (Ej: 'secrets/123/update', 'services/999/destroy')
+        id = segments[1]
+        action_name = segments[2]
+      end
+
+      { controller: controller_name, action: action_name, id: id }
     end
 
-    def open?
-      (connection.status == :open) &&
-        (@rabbit_channel.status == :open)
+    def consume!
+      queue.subscribe(manual_ack: true, block: true) do |delivery_info, properties, body|
+        Rails.logger.debug("DeliveryInfo: #{delivery_info}")
+        Rails.logger.debug("Properties: #{properties}")
+        Rails.logger.debug("Body: #{body}")
+
+        raise StandardError, 'Undefined properties.type' if properties.type.blank?
+
+        route = parse_route(properties.type)
+
+        headers = {
+          type: properties.type,
+          controller: route[:controller],
+          action: route[:action],
+          id: route[:id],
+          content_type: properties.content_type,
+          content_encoding: properties.content_encoding,
+          correlation_id: properties.correlation_id
+        }
+
+        controller = "rabbit/controllers/#{route[:controller]}".camelize.constantize
+        response_payload = controller.call(headers: headers, body: body)
+
+        Rails.logger.debug("Response: #{response_payload}")
+
+        if properties.reply_to.present?
+          Rails.logger.info("Sending response to #{properties.reply_to}")
+
+          # Publicar la respuesta directamente a la cola de respuesta
+          # No se necesita un exchange, se publica a la cola por su nombre
+          channel.default_exchange.publish(
+            response_payload.to_json,
+            routing_key: properties.reply_to,
+            correlation_id: properties.correlation_id
+          )
+        end
+
+        channel.ack(delivery_info.delivery_tag)
+      rescue NoMethodError => e # action controller no exist
+        Rails.logger.error(e)
+        channel.reject(delivery_info.delivery_tag, false)
+      rescue NameError => e # Controller no exist
+        Rails.logger.error(e)
+        channel.reject(delivery_info.delivery_tag, false)
+      rescue StandardError => e
+        Rails.logger.error("Error processing message: #{e.message} (#{e.class})")
+        # Reject the message and do NOT re-queue it immediately.
+        channel.reject(delivery_info.delivery_tag, false)
+      end
     end
 
-    def connection_openned?
-      [:open, :connecting, :connected].include?(connection.status)
+    # El success y el error es para tener compatibilidad con el bug_bunny
+    def build_response(status:, body:)
+      case status
+      when 'success' then body # Old compatibility
+      when 'error' then raise BugBunny::ResponseError::InternalServerError, body # Old compatibility
+      when 200, 201 then body
+      when 204 then nil
+      when 400 then raise BugBunny::ResponseError::BadRequest, body.to_json
+      when 404 then raise BugBunny::ResponseError::NotFound
+      when 406 then raise BugBunny::ResponseError::NotAcceptable
+      when 422 then raise BugBunny::ResponseError::UnprocessableEntity, body.to_json
+      when 500 then raise BugBunny::ResponseError::InternalServerError, body.to_json
+      else
+        raise BugBunny::ResponseError::Base, body.to_json
+      end
     end
 
-    # status = :open, :connected, :connecting,
-    # :closing, :disconnected, :not_connected, :closed
-    def create_connection
-      # if WisproUtils::Config.defaults.use_tls
-      #   path = (Rails.root.join('private', 'certs') rescue './private/certs')
-      #   options.merge!(tls:                 true,
-      #                  port:                ENV['RABBIT_SSL_PORT'] || 5671,
-      #                  log_level:           ENV['LOG_LEVEL'] || :debug,
-      #                  verify_peer:         true,
-      #                  tls_cert:            "#{path}/cert.pem",
-      #                  tls_key:             "#{path}/key.pem",
-      #                  tls_ca_certificates: ["#{path}/ca.pem"])
-      # end
-      options = {}
-
-      raise "Need user" if BugBunny.configuration.user.blank?
-      raise "Need pass" if BugBunny.configuration.pass.blank?
-      raise "Need host" if BugBunny.configuration.host.blank?
-
-      bunny_logger = BugBunny.configuration.logger || ::Logger.new('./log/bunny.log', 7, 10485760)
-      bunny_logger.level = BugBunny.configuration.log_level || ::Logger::INFO
-
-      options.merge!(
-        heartbeat_interval: 20, # 20.seconds per connection
-        logger: bunny_logger,
-        # Override bunny client_propierties
-        client_properties: { product: identifier, platform: '' }
-      )
+    def self.run_consumer(connection:, exchange:, exchange_type:, queue_name:, routing_key:, queue_opts: {})
+      app = new(connection: connection)
+      app.build_exchange(name: exchange, type: exchange_type)
+      app.build_queue(name: queue_name, opts: queue_opts)
+      app.queue.bind(app.exchange, routing_key: routing_key)
+      app.consume!
+      health_check_thread = start_health_check(app, queue_name: queue_name, exchange_name: exchange, exchange_type: exchange_type)
+      health_check_thread.wait_for_termination
+      raise 'Health check error: Forcing reconnect.'
+    rescue StandardError => e
+      # Esto lo pongo por que si levanto el rabbit y el consumer a la vez
+      # El rabbit esta una banda de tiempo hasta aceptar conexiones, por lo que
+      # el consumer explota 2 millones de veces, por lo tanto con esto hago
+      # la espera ocupada y me evito de ponerlo en el entrypoint-docker
+      Rails.logger.error("[RABBIT] Consumer error: #{e.message} (#{e.class})")
+      Rails.logger.debug("[RABBIT] Consumer error: #{e.backtrace}")
+      connection&.close
+      sleep RABBIT_NETWORK_RECOVERY
+      retry
+    end
 
-      logger&.debug('Stablish new connection to rabbit')
-      logger&.debug(BugBunny.configuration.url)
+    def self.start_health_check(app, queue_name:, exchange_name:, exchange_type:)
+      task = Concurrent::TimerTask.new(execution_interval: RABBIT_HEALT_CHECK) do
+        # con esto veo si el exachange o la cola no la borraron desde la vista de rabbit
+        app.channel.exchange_declare(exchange_name, exchange_type, passive: true)
+        app.channel.queue_declare(queue_name, passive: true)
+      rescue Bunny::NotFound
+        Rails.logger.error("Health check failed: Queue '#{queue_name}' no longer exists!")
+        app.connection.close
+        task.shutdown # Detenemos la tarea para que no se ejecute de nuevo
+      rescue StandardError => e
+        Rails.logger.error("Health check error: #{e.message}. Forcing reconnect.")
+        app.connection.close
+        task.shutdown
+      end
 
-      rabbit_conn = Bunny.new(BugBunny.configuration.url, options)
-      rabbit_conn.start
+      task.execute
+      task
+    end
 
-      logger&.debug("New status connection: #{rabbit_conn.status}")
+    def self.create_connection(host: nil, username: nil, password: nil, vhost: nil)
+      bunny = Bunny.new(
+        host: host || BugBunny.configuration.host,
+        username: username || BugBunny.configuration.username,
+        password: password || BugBunny.configuration.password,
+        vhost: vhost || BugBunny.configuration.vhost,
+        logger: BugBunny.configuration.logger || Rails.logger,
+        automatically_recover: BugBunny.configuration.automatically_recover || false,
+        network_recovery_interval: BugBunny.configuration.network_recovery_interval || 5,
+        connection_timeout: BugBunny.configuration.connection_timeout || 10,
+        read_timeout: BugBunny.configuration.read_timeout || 90,
+        write_timeout: BugBunny.configuration.write_timeout || 90,
+        heartbeat: BugBunny.configuration.heartbeat || 30,
+        continuation_timeout: BugBunny.configuration.continuation_timeout || 15_000
+      )
 
-      self.connection = rabbit_conn
+      bunny.tap(&:start)
     end
   end
 end

data/lib/bug_bunny/resource.rb

@@ -0,0 +1,226 @@
+module BugBunny
+  class Resource
+    include ActiveModel::API
+    include ActiveModel::Attributes
+    include ActiveModel::Dirty
+    include ActiveModel::Validations
+
+    class << self
+      attr_accessor :resource_path
+      attr_writer :resource_name
+
+      def resource_name
+        @resource_name ||= name.demodulize.underscore
+      end
+
+      def inherited(subclass)
+        super
+
+        subclass.resource_path = resource_path if resource_path.present?
+      end
+    end
+
+    class ExchangeScope
+      attr_reader :exchange_name, :klass
+
+      def initialize(klass, exchange_name)
+        @klass = klass
+        @exchange_name = exchange_name
+      end
+
+      def method_missing(method_name, *args, **kwargs, &block)
+        if @klass.respond_to?(method_name, true)
+          kwargs[:exchange] = @exchange_name
+          @klass.execute(method_name.to_sym, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @klass.respond_to?(method_name, true) || super
+      end
+    end
+
+    attribute :persisted, :boolean, default: false
+
+    def initialize(attributes = {})
+      attributes.each do |key, value|
+        attribute_name = key.to_sym
+        type = guess_type(value)
+
+        next if self.class.attribute_names.include?(attribute_name.to_s)
+
+        self.class.attribute attribute_name, type if type.present?
+      end
+
+      super(attributes)
+
+      @previously_persisted = persisted
+      clear_changes_information if persisted?
+    end
+
+    def assign_attributes(attrs)
+      return if attrs.blank?
+
+      attrs.each do |key, val|
+        setter_method = "#{key.to_s.underscore}="
+
+        next unless respond_to?(setter_method)
+
+        send(setter_method, val)
+      end
+    end
+
+    def guess_type(value)
+      case value
+      when Integer then :integer
+      when Float then :float
+      when Date then :date
+      when Time, DateTime then :datetime
+      when TrueClass, FalseClass then :boolean
+      when String then :string
+      end
+    end
+
+    def persisted?
+      persisted
+    end
+
+    def update(attrs_changes)
+      assign_attributes(attrs_changes)
+      save
+    end
+
+    def changes_to_send
+      attrs = {}
+      changes.each { |attribute, values| attrs[attribute] = values[1] }
+      attrs
+    end
+
+    def save
+      action = persisted? ? self.class.update_action.to_sym : self.class.create_action.to_sym
+
+      return self if persisted? && changes.empty?
+
+      obj = self.class.publisher.send(action, exchange: current_exchange, message: changes_to_send)
+
+      assign_attributes(obj) # refresco el objeto
+      self.persisted = true
+      @previously_persisted = true
+      clear_changes_information
+      true
+    rescue BugBunny::ResponseError::UnprocessableEntity => e
+      load_remote_rabbit_errors(e.message)
+      false
+    end
+
+    def destroy
+      return self unless persisted?
+
+      # Llamada al PUBLISHER sin el argumento 'box'
+      self.class.publisher.send(destroy_action.to_sym, exchange: current_exchange, id: id)
+
+      self.persisted = false
+      true
+    rescue BugBunny::ResponseError::UnprocessableEntity => e
+      load_remote_rabbit_errors(e.message)
+      false
+    end
+
+    def current_exchange
+      self.class.current_exchange
+    end
+
+    def self.for_exchange(exchange_name)
+      raise ArgumentError, 'Exchange name must be specified.' if exchange_name.blank?
+
+      ExchangeScope.new(self, exchange_name)
+    end
+
+    def self.execute(name, *args, **kwargs, &block)
+      original_exchange = Thread.current[:bugbunny_current_exchange]
+      Thread.current[:bugbunny_current_exchange] = kwargs[:exchange]
+      begin
+        kwargs.delete(:exchange)
+        send(name, *args, **kwargs, &block)
+      ensure
+        Thread.current[:bugbunny_current_exchange] = original_exchange
+      end
+    end
+
+    def self.current_exchange
+      Thread.current[:bugbunny_current_exchange]
+    end
+
+    def self.all
+      where
+    end
+
+    def self.where(query = {})
+      body = publisher.send(index_action.to_sym, exchange: current_exchange, message: query)
+      instances = []
+
+      body.each do |obj|
+        instance = new
+        instance.assign_attributes(obj.merge(persisted: true))
+        instances << instance
+      end
+
+      instances
+    end
+
+    def self.find(id)
+      obj = publisher.send(show_action.to_sym, exchange: current_exchange, id: id)
+      return if obj.blank?
+
+      instance = new
+      instance.assign_attributes(obj.merge(persisted: true))
+      instance
+    end
+
+    def self.create(payload)
+      instance = new(payload)
+      instance.save
+      instance
+    end
+
+    def self.index_action
+      :index
+    end
+
+    def self.show_action
+      :show
+    end
+
+    def self.create_action
+      :create
+    end
+
+    def self.update_action
+      :update
+    end
+
+    def self.destroy_action
+      :destroy
+    end
+
+    def self.publisher
+      @publisher ||= if resource_path.end_with?('/')
+                       [resource_path, resource_name].join('').camelize.constantize
+                     else
+                       [resource_path, resource_name].join('/').camelize.constantize
+                     end
+    end
+
+    def load_remote_rabbit_errors(remote_errors)
+      JSON.parse(remote_errors).each do |attribute, errors|
+        errors.each do |error|
+          self.errors.add(attribute, error['error'], **error.except('error').symbolize_keys)
+        end
+      end
+    end
+
+    private_class_method :all, :where, :find, :create
+  end
+end

data/lib/bug_bunny/version.rb

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

data/lib/bug_bunny.rb

@@ -1,22 +1,13 @@
 # frozen_string_literal: true
 
 require 'bunny'
-require_relative "bug_bunny/version"
-require_relative "bug_bunny/config"
-require_relative "bug_bunny/adapter"
-require_relative "bug_bunny/controller"
-require_relative "bug_bunny/exception"
-require_relative "bug_bunny/message"
-require_relative "bug_bunny/queue"
-require_relative "bug_bunny/rabbit"
-require_relative "bug_bunny/response"
-require_relative "bug_bunny/security"
-require_relative "bug_bunny/helpers"
-
-if defined? ::Rails::Railtie
-  ## Rails only files
-  require 'bug_bunny/railtie'
-end
+require_relative 'bug_bunny/version'
+require_relative 'bug_bunny/config'
+require_relative 'bug_bunny/controller'
+require_relative 'bug_bunny/publisher'
+require_relative 'bug_bunny/exception'
+require_relative 'bug_bunny/rabbit'
+require_relative 'bug_bunny/resource'
 
 module BugBunny
   class << self