bug_bunny 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d3bbeb691836f8f7b516454ed095e36fe7e719dc99f8a435fb58e2ed995e2d80
+  data.tar.gz: 8c1b3ed5758f0a19d0ee73233a4b92e328aaa114a18c851433f2bedbb2edeabe
+SHA512:
+  metadata.gz: 0e7cbbe33d45b497526a1a35b6d841bfd141edda37baf91975d64d218617f2cb8d8a9ec858efd4d75097d0b564cb0f96ae7326d7cb9be51c9ec926e621882b6c
+  data.tar.gz: c59537749ecd8c3dab9cff99c4f41ad5a62af569ddbbad13223ec3b3ad2ed9f2c3acaf96d6a736718afbfe5bd40e28dcfe147c61e5e5d3861fc71007db7580b4

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog
+## Version 0.1.0
+Migration bunny logic from utils

data/Gemfile

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

data/README.md

@@ -0,0 +1,31 @@
+# BugBunny
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/bug_bunny`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/bug_bunny.

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/bug_bunny.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lib/bug_bunny/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "bug_bunny"
+  spec.version = BugBunny::VERSION
+  spec.authors = ["gabix"]
+  spec.email = ["gab.edera@gmail.com"]
+
+  spec.summary = "Gem for sync and async comunication via rabbit bunny."
+  spec.description = "Gem for sync and async comunication via rabbit bunny."
+  spec.homepage = "https://github.com/gedera/bug_bunny"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/gedera/bug_bunny"
+  spec.metadata["changelog_uri"] = "https://github.com/gedera/bug_bunny/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  spec.add_dependency "bunny", "~> 2.20"
+  spec.add_development_dependency "rubocop"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/bug_bunny/adapter.rb

@@ -0,0 +1,384 @@
+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,
+                  :consume_response
+
+    def initialize
+      @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?
+        consume_response || 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
+
+    def self.health_check(request: nil)
+      message_to_publish = ::BugBunny::Message.new(service_action: self::SERVICE_HEALTH_CHECK, body: {})
+
+      request ||= self::ROUTING_KEY_SYNC_REQUEST
+
+      begin
+        service_adapter = new
+        sync_queue = service_adapter.build_queue(
+          request,
+          self::QUEUES_PROPS[self::ROUTING_KEY_SYNC_REQUEST]
+        )
+      rescue ::BugBunny::Exception::ComunicationRabbitError => e
+        (service_adapter ||= nil).try(:close_connection!)
+        return ::BugBunny::Response.new(status: false, response: e.message)
+      end
+
+      service_adapter.publish_and_consume!(message_to_publish, sync_queue, check_consumers_count: true)
+
+      service_adapter.close_connection! # ensure the adapter is close
+
+      if service_adapter.communication_response.success?
+        msg = service_adapter.service_message
+
+        result = case msg.status
+                 when 'success'
+                   { status: true }
+                 when 'error', 'critical'
+                   { status: false }
+                 end
+
+        service_adapter.consume_response = ::BugBunny::Response.new(result)
+      end
+
+      service_adapter.make_response
+    end
+  end
+end

data/lib/bug_bunny/controller.rb

@@ -0,0 +1,16 @@
+module BugBunny
+  class Controller
+    def self.health_check(_message)
+      { status: :success, body: {} }
+    end
+
+    def self.exec_action(message)
+      send(message.service_action, message)
+    end
+
+    def self.method_missing(name, message, *args, &block)
+      Session.message = message
+      message.build_message(reply_to: message.reply_to).server_no_action!
+    end
+  end
+end

data/lib/bug_bunny/exception.rb

@@ -0,0 +1,61 @@
+module BugBunny
+  class Exception
+
+    class ServiceError < StandardError
+      def to_s
+        :service_error
+      end
+    end
+
+    class NeedSignature < StandardError
+      def to_s
+        :need_signature
+      end
+    end
+
+    class InvalidSignature < StandardError
+      def to_s
+        :invalid_signature
+      end
+    end
+
+    class GatewayError < StandardError
+      def to_s
+        :gateway_error
+      end
+    end
+
+    class UltraCriticError < StandardError
+    end
+
+    class ComunicationRabbitError < StandardError
+      attr_accessor :backtrace
+
+      def initialize(msg, backtrace)
+        @backtrace = backtrace
+        super(msg)
+      end
+    end
+
+    class RetryWithoutError < StandardError
+      def to_s
+        "retry_sidekiq_without_error"
+      end
+
+      def backtrace
+        []
+      end
+    end
+
+    ServiceClasses = [
+      Exception::NeedSignature,
+      Exception::InvalidSignature,
+      Exception::ServiceError,
+      Exception::GatewayError,
+      Exception::RetryWithoutError
+    ]
+
+    # Exceptions from ActiveRecord::StatementInvalid
+    PG_EXCEPTIONS_TO_EXIT = %w[PG::ConnectionBad PG::UnableToSend].freeze
+  end
+end

data/lib/bug_bunny/helpers.rb

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,161 @@
+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

@@ -0,0 +1,23 @@
+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

data/lib/bug_bunny/rabbit.rb

@@ -0,0 +1,110 @@
+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
+    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
+    end
+
+    def channel
+      open? ? @rabbit_channel : set_channel
+    end
+
+    def close
+      @rabbit_channel.close if defined?(@rabbit_channel)
+      connection.close if connection.present?
+    rescue Bunny::ChannelAlreadyClosed
+      nil
+    end
+
+    def close_channel
+      @rabbit_channel.close if defined?(@rabbit_channel)
+    end
+
+    def status
+      {
+        connection: connection.status,
+        channel: @rabbit_channel.status,
+        identifier: identifier
+      }
+    end
+
+    def open?
+      (connection.status == :open) &&
+        (@rabbit_channel.status == :open)
+    end
+
+    def connection_openned?
+      [:open, :connecting, :connected].include?(connection.status)
+    end
+
+    # status = :open, :connected, :connecting,
+    # :closing, :disconnected, :not_connected, :closed
+    def create_connection
+      options = {}
+
+      # 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
+
+      logger&.debug('Stablish new connection to rabbit')
+      logger&.debug("amqp://#{ENV['RABBIT_USER']}:" \
+                   "#{ENV['RABBIT_PASS']}@#{ENV['RABBIT_HOST']}" \
+                   "/#{ENV['RABBIT_VIRTUAL_HOST']}")
+
+
+      bunny_logger = ::Logger.new('./log/bunny.log', 7, 10485760)
+      bunny_logger.level = ::Logger::DEBUG
+      options.merge!(
+        heartbeat_interval: 20,  # 20.seconds per connection
+        logger: bunny_logger,
+        # Override bunny client_propierties
+        client_properties: { product: identifier, platform: ''}
+      )
+
+      rabbit_conn = Bunny.new("amqp://#{ENV['RABBIT_USER']}" \
+                              ":#{ENV['RABBIT_PASS']}@"\
+                              "#{ENV['RABBIT_HOST']}/"\
+                              "#{ENV['RABBIT_VIRTUAL_HOST']}",
+                              options)
+      rabbit_conn.start
+      logger&.debug("New status connection: #{rabbit_conn.status}")
+
+      self.connection = rabbit_conn
+    end
+  end
+end

data/lib/bug_bunny/response.rb

@@ -0,0 +1,15 @@
+module BugBunny
+  class Response
+    attr_accessor :status, :response, :exception
+
+    def initialize(attrs={})
+      @status    = attrs[:status]
+      @response  = attrs[:response]
+      @exception = attrs[:exception]
+    end
+
+    def success?
+      @status
+    end
+  end
+end

data/lib/bug_bunny/security.rb

@@ -0,0 +1,19 @@
+module BugBunny
+  module Security
+    def self.sign_message(secret, message)
+      digest = OpenSSL::Digest.new('SHA512')
+      private_key = OpenSSL::PKey::RSA.new(secret)
+      Base64.encode64(private_key.sign(digest, message))
+    end
+
+    def self.check_sign(key, signature, message)
+      pub_key = OpenSSL::PKey::RSA.new(key)
+      digest = OpenSSL::Digest.new('SHA512')
+      if pub_key.verify(digest, Base64.decode64(signature), message)
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/bug_bunny/version.rb

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

data/lib/bug_bunny.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bunny'
+require_relative "bug_bunny/version"
+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"
+
+module BugBunny
+end

data/sig/bug_bunny.rbs

@@ -0,0 +1,4 @@
+module BugBunny
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: bug_bunny
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- gabix
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+  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'
+description: Gem for sync and async comunication via rabbit bunny.
+email:
+- gab.edera@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- bug_bunny.gemspec
+- lib/bug_bunny.rb
+- lib/bug_bunny/adapter.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/rabbit.rb
+- lib/bug_bunny/response.rb
+- lib/bug_bunny/security.rb
+- lib/bug_bunny/version.rb
+- sig/bug_bunny.rbs
+homepage: https://github.com/gedera/bug_bunny
+licenses: []
+metadata:
+  homepage_uri: https://github.com/gedera/bug_bunny
+  source_code_uri: https://github.com/gedera/bug_bunny
+  changelog_uri: https://github.com/gedera/bug_bunny/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key: 
+specification_version: 4
+summary: Gem for sync and async comunication via rabbit bunny.
+test_files: []