bug_bunny 1.0.0 → 2.0.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - gabix
@@ -15,28 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.20'
+        version: '2.24'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.20'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.24'
 description: Gem for sync and async comunication via rabbit bunny.
 email:
 - gab.edera@gmail.com
@@ -45,25 +31,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- Gemfile
 - README.md
 - Rakefile
 - lib/bug_bunny.rb
-- lib/bug_bunny/adapter.rb
 - lib/bug_bunny/config.rb
 - lib/bug_bunny/controller.rb
 - lib/bug_bunny/exception.rb
-- lib/bug_bunny/helpers.rb
-- lib/bug_bunny/message.rb
-- lib/bug_bunny/queue.rb
+- lib/bug_bunny/publisher.rb
 - lib/bug_bunny/rabbit.rb
-- lib/bug_bunny/railtie.rb
-- lib/bug_bunny/response.rb
-- lib/bug_bunny/security.rb
+- lib/bug_bunny/resource.rb
 - lib/bug_bunny/version.rb
 - sig/bug_bunny.rbs
 homepage: https://github.com/gedera/bug_bunny
-licenses: []
+licenses:
+- MIT
 metadata:
   homepage_uri: https://github.com/gedera/bug_bunny
   source_code_uri: https://github.com/gedera/bug_bunny

data/Gemfile

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in bug_bunny.gemspec
-gemspec
-
-gem "rake", "~> 13.0"

data/lib/bug_bunny/adapter.rb

@@ -1,347 +0,0 @@
-module BugBunny
-  class Adapter
-    PERSIST_MESSAGE = true
-
-    SERVICE_HEALTH_CHECK = :health_check
-    TIMEOUT             = 3
-    BOMBA               = :bomba
-    PUBLISH_TIMEOUT     = :publish_timeout
-    CONSUMER_TIMEOUT    = :consumer_timeout
-    COMUNICATION_ERROR  = :comunication_error
-    CONSUMER_COUNT_ZERO = :consumer_count_zero
-
-    PG_EXCEPTIONS_TO_EXIT = %w[PG::ConnectionBad PG::UnableToSend].freeze
-
-    attr_accessor :consumer,
-                  :rabbit,
-                  :logger,
-                  :time_to_wait,
-                  :communication_response,
-                  :service_message
-
-    def initialize(attrs = {})
-      @logger = Logger.new('./log/bug_bunny.log', 'monthly')
-      @communication_response = ::BugBunny::Response.new status: false
-      @time_to_wait = 2
-      create_adapter_with_rabbit
-    end
-
-    def publish!(message, publish_queue, opts = {})
-      Timeout::timeout(TIMEOUT) do
-        if opts[:check_consumers_count] && publish_queue.check_consumers.zero?
-          self.communication_response = ::BugBunny::Response.new(status: false, response: CONSUMER_COUNT_ZERO)
-          return
-        end
-
-        publish_opts = { routing_key: publish_queue.name,
-                         persistent: opts[:persistent],
-                         correlation_id: message.correlation_id }
-
-        publish_opts[:reply_to] = opts[:reply_to] if opts[:reply_to]
-
-        # Esta es la idea en el caso que nos pongamos mas mañosos y queramos cambiar las exchange a la hora de publicar.
-        # _exchange = if opts.has_key?(:exchange_type)
-        #               channel.exchange(opts[:exchange_type].to_s, { type: opts[:exchange_type] })
-        #             else
-        #               exchange
-        #             end
-        # _exchange.publish(message.to_json, publish_opts)
-        logger.debug("#{publish_queue.name}-Send Request: (#{message})")
-
-        rabbit.exchange.publish(message.to_json, publish_opts)
-        rabbit.channel.wait_for_confirms if rabbit.confirm_select
-
-        self.communication_response = ::BugBunny::Response.new(status: true)
-      end
-    rescue Timeout::Error => e
-      logger.error(e)
-      close_connection!
-      self.communication_response = ::BugBunny::Response.new(status: false, response: PUBLISH_TIMEOUT, exception: e)
-    rescue StandardError => e
-      logger.error(e)
-      close_connection!
-      self.communication_response = ::BugBunny::Response.new(status: false, response: BOMBA, exception: e)
-    end
-
-    def consume!(queue, thread: false, manual_ack: true, exclusive: false, block: true, opts: {})
-      Signal.trap('INT') { exit }
-
-      logger.debug("Suscribe consumer to: #{queue.name}")
-      logger.debug("ENTRO AL CONSUMER #{rabbit.try(:identifier)}")
-
-      self.consumer = queue.rabbit_queue.subscribe(manual_ack: manual_ack, exclusive: exclusive, block: block) do |delivery_info, metadata, json_payload|
-        # Session depends on thread info, subscribe block cleans thread info
-        # ::Session.init unless Session.tags_context
-
-        begin
-          payload = ActiveSupport::JSON.decode(json_payload).deep_symbolize_keys # Timezones pulenteado
-        rescue StandardError
-          payload = JSON.parse(json_payload).deep_symbolize_keys
-        end
-
-        # Session for Sentry logger
-        # locale, version, service_name
-        # payload.except(:body, :service_name).each do |k, v|
-        #   Session.assign(k, v)
-        # end
-        # Session.from_service = payload[:service_name]
-        # Session.correlation_id = metadata.correlation_id
-        # Session.queue_name = queue.name
-
-        # unless defined?(ActiveRecord) && ActiveRecord::Base.connection_pool.with_connection(&:active?)
-        #   logger.error('[PG] PG connection down')
-        #   exit 7
-        # end
-
-        begin
-          message = ::BugBunny::Message.new(correlation_id: metadata.correlation_id, reply_to: metadata.reply_to, **payload)
-
-          # Default sentry info
-          # ::Session.request_id = message.correlation_id rescue nil
-          # ::Session.tags_context.merge!(
-          #   server_version: message.version,
-          #   service_action: message.service_action,
-          #   service_name:   message.service_name,
-          #   isp_id:         (message.body&.fetch(:isp_id, nil) rescue nil)
-          # )
-          # ::Session.extra_context[:message] = message.body
-
-          logger.info("#{queue.name}-Received Request: (#{message.service_action})")
-          logger.debug("#{queue.name}-Received Request: (#{message})")
-          logger.debug("Message will be yield")
-          logger.debug("Block given?  #{block_given?}")
-          yield(message) if block_given?
-          logger.debug('Message processed')
-
-          begin
-            Timeout.timeout(5) do
-              rabbit.channel.ack delivery_info.delivery_tag if delivery_info[:consumer].manual_acknowledgement?
-            end
-          rescue Timeout::Error => e
-            logger.debug("Rabbit Identifier: #{rabbit.try(:identifier)} can not check manual_ack #{e.to_s}")
-          rescue ::StandardError => e
-            logger.debug("Rabbit Identifier: #{rabbit.try(:identifier)} can not check manual_ack #{e.to_s}")
-          end
-
-          self.service_message = message
-          self.communication_response = ::BugBunny::Response.new(status: true)
-        rescue ::SystemExit => e # Ensure exit code
-          raise e
-        rescue => e
-          logger.debug("Rabbit Identifier: #{rabbit.try(:identifier)}")
-          logger.error(e)
-
-          close_connection!
-
-          # Session.clean!
-          self.communication_response = ::BugBunny::Response.new(status: false, response: BOMBA, exception: e)
-        end
-
-        if thread # sync consumer flag :D
-          begin
-            Timeout::timeout(1) do
-              delivery_info[:consumer].cancel
-            end
-          rescue Timeout::Error => e
-            close_connection!
-            thread.exit
-          end
-          close_connection!
-          thread.exit
-        end
-      end
-
-      if thread
-        close_connection!
-        thread.exit
-      else
-        while true
-          begin
-            logger.debug("SALIO DEL CONSUMER #{rabbit.try(:identifier)}")
-            logger.debug(rabbit.status)
-            exit # consumer.cancel
-          rescue Bunny::NotAllowedError => e
-            logger.debug("NOT ALLOWED #{e.to_s}")
-            break
-          rescue Timeout::Error => e
-            if queue.rabbit_queue.channel.status == :closed || queue.rabbit_queue.channel.connection.status == :closed
-              logger.debug("Channel or connection closed")
-              break
-            end
-
-            sleep time_to_wait
-            logger.debug("Rabbit Identifier: #{rabbit.try(:identifier)}")
-            logger.error(e)
-            retry
-          rescue StandardError => e
-            if queue.rabbit_queue.channel.status == :closed || queue.rabbit_queue.channel.connection.status == :closed
-              logger.debug("Channel or connection closed")
-              break
-            end
-
-            sleep time_to_wait
-            logger.debug("Rabbit Identifier: #{rabbit.try(:identifier)}")
-            logger.error(e)
-            retry
-          end
-        end
-      end
-    rescue Timeout::Error => e
-      logger.debug("Rabbit Identifier: #{rabbit.try(:identifier)}")
-      logger.error(e)
-      close_connection!
-      ::BugBunny::Response.new(status: false, response: CONSUMER_TIMEOUT, exception: e)
-    rescue StandardError => e
-      logger.debug("Rabbit Identifier: #{rabbit.try(:identifier)}")
-      logger.error(e)
-      close_connection!
-      ::BugBunny::Response.new(status: false, response: BOMBA, exception: e)
-    end
-
-    def publish_and_consume!(publish_message, sync_queue, opts={})
-      reply_queue = build_queue('', initialize: true, exclusive: true, durable: false, auto_delete: true)
-
-      retries = 0
-      begin
-        publish!(publish_message, sync_queue, opts.merge(reply_to: reply_queue.name))
-      rescue
-        if (retries += 1) <= 3
-          sleep 0.5
-          retry
-        end
-
-        close_connection!
-        raise
-      end
-
-      return communication_response unless communication_response.success?
-
-      t = Thread.new do
-        retries = 0
-        begin
-          consume!(reply_queue, thread: Thread.current, exclusive: true) do |msg|
-            yield(msg) if block_given?
-          end
-        rescue
-          if (retries += 1) <= 3
-            sleep 0.5
-            retry
-          end
-          raise
-        end
-      end
-      t.join
-      communication_response
-    end
-
-    def build_queue(name, opts = {})
-      init = opts.key?(:initialize) ? opts[:initialize] : true
-      new_queue = ::BugBunny::Queue.new(opts.merge(name: name))
-
-      if init
-        logger.debug("Building rabbit new_queue: #{name} status: #{rabbit.status} queue_options: #{new_queue.options}")
-
-        retries = 0
-        begin
-          built_queue = rabbit.channel.queue(new_queue.name.to_s, new_queue.options)
-        rescue StandardError
-          if (retries += 1) <= 3
-            sleep 0.5
-            retry
-          end
-          raise
-        end
-
-        new_queue.rabbit_queue = built_queue
-        new_queue.name = new_queue.rabbit_queue.name
-      end
-
-      new_queue
-    rescue Timeout::Error, StandardError => e
-      logger.debug("Rabbit Identifier: #{rabbit.try(:identifier)}")
-      logger.debug("Status adapter created: #{rabbit.status}")
-      logger.error(e)
-
-      close_connection!
-      raise Exception::ComunicationRabbitError.new(COMUNICATION_ERROR, e.backtrace)
-    end
-
-    def self.make_response(comunication_result, consume_result = nil)
-      if comunication_result.success?
-        consume_result || comunication_result
-      else
-        comunication_result.response = comunication_result.response.to_s
-        comunication_result
-      end
-    end
-
-    def make_response
-      if communication_response.success?
-        service_message || communication_response
-      else
-        communication_response.response = communication_response.response.to_s
-        communication_response
-      end
-    end
-
-    def status
-      rabbit.try(:status)
-    end
-
-    def close_connection!
-      rabbit.try(:close)
-    end
-
-    def check_pg_exception!(exception)
-      # el consumidor no reconecta (rails tasks) asi que salimos a la goma
-      if PG_EXCEPTIONS_TO_EXIT.any? { |msg| exception.try(:message)&.starts_with?(msg) }
-        exit 7 # salimos con un int especial para identificarlo
-      end
-    end
-
-    private
-
-    # AMQ::Protocol::EmptyResponseError: Este error lo note cuando el rabbit
-    # acepta la connection pero aun no ha terminado de inicializar el servicio,
-    # por lo que salta esta exception.
-    # Errno::ECONNRESET: Este error se presenta cuando justo esta arrancando
-    # el rabbit y se quiere conectar al mismo. El rabbit resetea la connection,
-    # haciendo saltar esta exception.
-    def create_adapter_with_rabbit
-      self.rabbit = ::BugBunny::Rabbit.new(confirm_select: true, logger: logger)
-    rescue Bunny::NetworkFailure, Bunny::TCPConnectionFailed,
-           Bunny::ConnectionForced, AMQ::Protocol::EmptyResponseError,
-           Errno::ECONNRESET => e
-
-      logger.debug(e)
-      close_connection!
-      raise Exception::ComunicationRabbitError.new(COMUNICATION_ERROR, e.backtrace)
-    rescue OpenSSL::SSL::SSLError, OpenSSL::X509::CertificateError => e
-      # el `e.to_s` devuelve alguno de los sgtes errores. Por ej:
-      # SSL_connect returned=1 errno=0 state=unknown state: sslv3
-      # alert bad certificate
-      # SSL_CTX_use_PrivateKey: key values mismatch
-      # OpenSSL::X509::CertificateError: not enough data // headers too short
-      if respond_to?(:handle_ssl_issues)
-        handle_ssl_issues # esto pide los certificados de nuevo
-        @retries ||= 0
-        @retries += 1
-        sleep 1
-        retry if @retries < 4
-        @retries = 0 # reset the counter
-      end
-
-      # Si sigue fallando desp de 3 veces o no tiene definido el handle
-      # bombita rodriguez
-      logger.error(e)
-
-      close_connection!
-      raise Exception::ComunicationRabbitError.new(COMUNICATION_ERROR, e.backtrace)
-    rescue Timeout::Error, StandardError => e
-      logger.error(e)
-
-      close_connection!
-      raise Exception::ComunicationRabbitError.new(COMUNICATION_ERROR, e.backtrace)
-    end
-  end
-end

data/lib/bug_bunny/helpers.rb

@@ -1,36 +0,0 @@
-module BugBunny
-  module Helpers
-    extend self
-
-    def datetime_values_to_utc(data)
-      case data
-      when Hash
-        data.inject({}) {|memo, (k, v)| memo.merge!({k => datetime_values_to_utc(v)}) }
-      when Array
-        data.map {|e| datetime_values_to_utc(e) }
-      when DateTime, Time
-        data.to_time.utc.iso8601
-      else
-        data
-      end
-    end
-
-    def utc_values_to_local(data)
-      case data
-      when Hash
-        data.inject({}) {|memo, (k, v)| memo.merge!({k => utc_values_to_local(v)}) }
-      when Array
-        data.map {|e| utc_values_to_local(e) }
-      when DateTime, Time
-        data.to_time.localtime # ensure we always use Time instances
-      when /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:.*Z$/
-        t = Time.respond_to?(:zone) ? Time.zone.parse(data) : Time.parse(data)
-        t.to_time.localtime
-      when /^\d{4}-\d{2}-\d{2}$/
-        Date.parse(data)
-      else
-        data
-      end
-    end
-  end
-end

data/lib/bug_bunny/message.rb

@@ -1,161 +0,0 @@
-module BugBunny
-  class Message
-    # API ERROR RESPONSE KEY
-    FIELD_ERROR   = :field
-    SERVER_ERROR  = :server
-
-    # API ERROR RESPONSE CODES
-    MISSING_FIELD = :missing
-    UNKNOWN_FIELD = :unknown
-    NOT_FOUND     = :not_found
-    NO_ACTION     = :no_action
-    TIMEOUT       = :timeout
-    BOMBA         = :bomba
-
-    attr_accessor :correlation_id,
-                  :body,
-                  :signature,
-                  :errors,
-                  :status,
-                  :service_name,
-                  :service_action,
-                  :version,
-                  :reply_to,
-                  :exception
-
-    def initialize(opts = {})
-      @correlation_id = opts[:correlation_id] || SecureRandom.uuid
-      @body           = deserialize_body(opts[:body] || opts[:response] || {})
-      @errors         = opts[:errors]
-      @status         = opts[:status] || :success
-      @service_name   = opts[:service_name]
-      @service_action = opts[:service_action] # Deberiamos raisear si esto no viene...
-      @version        = opts[:version]
-      @signature      = opts[:signature]
-      @reply_to       = opts[:reply_to]
-      @exception      = opts[:exception]
-    end
-
-    def server_not_found!
-      server_error! [NOT_FOUND]
-    end
-
-    def server_timeout!
-      server_error! [TIMEOUT]
-    end
-
-    def server_no_action!
-      server_error! [NO_ACTION]
-    end
-
-    def server_error!(errors=nil)
-      self.status = :error
-      self.body = {}
-      if errors
-        self.errors ||= {}
-        self.errors[SERVER_ERROR] ||= []
-        self.errors[SERVER_ERROR] += [errors].flatten # just in case
-      else
-        self.exception = Exception::ServiceError.new
-      end
-      self
-    end
-
-    def signed?
-      signature.present?
-    end
-
-    def sign!(key)
-      self.signature = ::BugBunny::Security.sign_message(key, body.to_json)
-    end
-
-    def invalid_signature?(key)
-      !valid_signature?(key)
-    end
-
-    def valid_signature?(key)
-      return if signature.blank?
-
-      ::BugBunny::Security.check_sign(key, signature, body.to_json)
-    end
-
-    def formatted
-      resp = {
-        correlation_id: correlation_id,
-        version:        version,
-        status:         status,
-        service_name:   service_name,
-        service_action: service_action,
-        signature:      signature,
-        errors:         errors,
-        body:           serialize_body
-      }
-
-      if exception
-        # resp[:exception] = exception.backtrace.join("\n") rescue nil
-        resp[:exception] = [
-          exception.to_s,
-          exception.try(:backtrace) || []
-        ].flatten.join("\n") rescue exception.to_s
-
-        unless ::BugBunny::Exception::ServiceClasses.include?(exception.class)
-          self.exception = Exception::ServiceError.new
-        end
-        resp[:errors] ||= {}
-        unless resp[:errors][SERVER_ERROR]&.any?
-          resp[:errors][SERVER_ERROR] ||= []
-          resp[:errors][SERVER_ERROR] << exception.to_s
-        end
-        resp[:status] = self.status = :critical
-      end
-
-      resp
-    end
-
-    def to_json
-      formatted.to_json
-    end
-
-    def to_s
-      to_json # Asegurarse de que siempre se llame al "formatted"
-    end
-
-    def to_h
-      formatted
-    rescue StandardError
-      original_to_h
-    end
-
-    alias :original_to_h :to_h
-
-    def success?
-      status.to_sym == :success
-    end
-
-    def error?
-      status.to_sym == :error
-    end
-
-    def critical?
-      status.to_sym == :critical
-    end
-
-    def build_message(params = {})
-      Message.new({ version: version, correlation_id: correlation_id, service_action: service_action }.merge(params))
-    end
-
-    def serialize_body
-      Helpers.datetime_values_to_utc(body)
-    end
-
-    def deserialize_body(body)
-      Helpers.utc_values_to_local(body)
-    end
-
-    # def critical_response
-    #   ::BugBunny::ParserMessage.humanize_error(errors, :adapter)
-    # rescue StandarError
-    #   [:general_error]
-    # end
-  end
-end

data/lib/bug_bunny/queue.rb

@@ -1,23 +0,0 @@
-module BugBunny
-  class Queue
-    attr_accessor :name, :auto_delete, :durable, :exclusive, :rabbit_queue
-
-    def initialize(attrs={})
-      # "Real" queue  opts
-      @name        = attrs.fetch(:name, 'undefined')
-      @auto_delete = attrs.fetch(:auto_delete, true)
-      @durable     = attrs.fetch(:durable, false)
-      @exclusive   = attrs.fetch(:exclusive, false)
-    end
-
-    def options
-      { durable: durable, exclusive: exclusive, auto_delete: auto_delete }
-    end
-
-    def check_consumers
-      rabbit_queue.consumer_count
-    rescue StandardError
-      0
-    end
-  end
-end