async_request_reply 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 82844bb3ba5b9fd8531eaa9d2d4c7423dc75fc05328231f3453312e40c969874
+  data.tar.gz: fcf69875b436ac90400db0fea59d1f014930735cc3aa83595f671156b8802977
+SHA512:
+  metadata.gz: 32b54b50cb07199f46c6ec62dc65975eb672aee8c18810f8378eaa4c588c337904a3469342580c097089ecb3a493bffa690fb0d5eec037a8da511565fbe1d1cc
+  data.tar.gz: 77f45585605802ed482bc32a3a1aa3d681825e7d96d58ebaa7f0cdf85dd2d9cc5ca544f10a0a57c1f1cf13bcd8d7969426a1600b21ef5a0e991055ed62014265

data/lib/async_request_reply/config.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require 'ostruct'
+require 'logger'
+
+module AsyncRequestReply
+  class Config
+    DEFAULTS = {
+      repository_adapter: :redis,
+      redis_url_conection: 'redis://localhost:6379',
+      async_engine: :sidekiq,
+      logger: Logger.new(STDOUT)
+    }
+
+    @@message_packer_factories = []
+
+    attr_accessor :config
+
+    def initialize
+      @config ||= OpenStruct.new
+      config.repository_adapter = DEFAULTS[:repository_adapter]
+      config.redis_url_conection = DEFAULTS[:redis_url_conection]
+      config.async_engine = DEFAULTS[:async_engine]
+      config.logger = DEFAULTS[:logger]
+      super
+    end
+
+    def self.instance
+      @instance ||= new
+    end
+
+    def configure
+      yield(self)
+    end
+
+    def repository_adapter
+      return AsyncRequestReply::RepositoryAdapters::RedisRepositoryAdapter if config.repository_adapter == :redis
+      config.repository_adapter
+    end
+
+    def redis_url_conection
+      config.redis_url_conection
+    end
+
+    def async_engine
+      return AsyncRequestReply::WorkersEngine::Async if config.async_engine   == :async
+      return AsyncRequestReply::WorkersEngine::Sidekiq if config.async_engine == :sidekiq
+
+      config.async_engine
+    end
+
+    def async_engine=(value)
+      config.async_engine = value
+    end
+
+    def repository_adapter=(value)
+      config.repository_adapter = value
+    end
+
+    def redis_url_conection=(value)
+      config.redis_url_conection = value
+    end
+
+    def logger
+      config.logger
+    end
+
+    def message_packer_factories
+      @@message_packer_factories
+    end
+
+    def add_message_pack_factory
+      factory = yield({first_byte: nil, klass: nil, packer: nil, unpacker: nil})
+      factory[:klass].class_eval do
+        def as_json
+          self
+        end
+      end
+      @@message_packer_factories.push(factory)
+    end
+  end
+end

data/lib/async_request_reply/methods_chain.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module AsyncRequestReply
+  # A module providing functionality for chaining method calls on a constant.
+  # This class provides a method to execute a series of method calls in sequence on a given constant.
+  #
+  # == Example:
+  #  AsyncRequestReply::MethodsChain.run_methods_chain(1, [[:+, 1], [:*, 2]]) 
+  #  # => 4
+  #
+  # The methods in `attrs_methods` will be called in the order they are provided.
+  # If a method requires arguments, the arguments will be passed, otherwise the method will be called without arguments.
+  #
+  class MethodsChain
+    class << self
+      # Executes a chain of method calls on a given constant.
+      #
+      # This method allows chaining of method calls on a constant, where each method can optionally receive parameters.
+      # 
+      # The constant is first constantized (if it is a string, it will be converted to a constant), and then methods
+      # from the `attrs_methods` array are invoked on it in order.
+      #
+      # @param constant [Object] The constant (or any object) on which methods will be called.
+      # @param attrs_methods [Array<Array<Symbol, Object>>] An array of method names and corresponding arguments.
+      #   Each element should be a 2-element array where the first element is the method name (as a symbol),
+      #   and the second element is the argument to pass to that method. If the method does not require arguments,
+      #   the second element can be omitted.
+      # 
+      # @return [Object] The result of the last method call in the chain.
+      #
+      # @example
+      #   AsyncRequestReply::MethodsChain.run_methods_chain(1, [[:+, 1], [:*, 2]]) 
+      #   # => 4
+      #
+      # @example
+      #   AsyncRequestReply::MethodsChain.run_methods_chain("Math::PI", [[:*, 2], [:+, 1]])
+      #   # => 7.141592653589793
+      def run_methods_chain(constant, attrs_methods = [])
+        # The constant is either a string that needs to be constantized or an already defined constant.
+        attrs_methods.inject(constant.is_a?(String) ? constant.constantize : constant) do |constantized, method|
+
+          if method[1]
+            args = [method[1]].flatten.select{|arg| !arg.is_a?(Hash)}
+            kwargs = ([method[1]].flatten.find{|arg| arg.is_a?(Hash)} || {}).symbolize_keys
+
+            # If the argument is a Proc, pass it as a block to the method call.
+            next constantized.send(method[0], &args[0]) if args.size == 1 && args[0].is_a?(Proc)
+
+            constantized.send(method[0], *args, **kwargs)
+
+          else
+            # If no argument is provided, call the method without parameters.
+            constantized.send(method[0])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/async_request_reply/repository_adapters/abstract_repository_adapter.rb

@@ -0,0 +1,17 @@
+module AsyncRequestReply
+	module RepositoryAdapters
+		class AbstractRepositoryAdapter
+			class << self
+				def get(uuid)
+					raise NotImplementedError
+				end
+				def del(uuid)
+					raise NotImplementedError
+				end
+				def setex(uuid, ttl, payload)
+					raise NotImplementedError
+				end
+			end
+		end
+	end
+end

data/lib/async_request_reply/repository_adapters/redis_repository_adapter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require_relative '../config'
+require_relative 'abstract_repository_adapter'
+require 'redis-client'
+
+module AsyncRequestReply
+	module RepositoryAdapters
+		class RedisRepositoryAdapter < AbstractRepositoryAdapter
+			class << self
+				def get(uuid)
+					client.call("GET", uuid)
+				end
+
+				def del(uuid)
+					client.call("DEL", uuid)
+				end
+
+				def setex(uuid, ttl, payload)
+					raise "Redis can`t save key #{uuid}" unless client.call("SET", uuid, payload, ex: ttl)
+					get(uuid)
+				end
+
+				def client
+					#TODO: ADD CONFIGURATION timeout and size of pool
+					@@redis ||= RedisClient.config(url: AsyncRequestReply::Config.instance.redis_url_conection).new_pool(timeout: 0.5, size: 5) 
+				end
+			end
+		end
+	end
+end

data/lib/async_request_reply/worker.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+require_relative 'config'
+require_relative 'methods_chain'
+
+module AsyncRequestReply
+	class Worker
+		# TODO-2023-10-22: Adicinar mais logs a classe.
+
+  	@@config = AsyncRequestReply::Config.instance
+
+	  STATUS = %i[waiting processing done unprocessable_entity internal_server_error]
+	  ONE_HOUR = 60*60
+	  LIVE_TIMEOUT = ONE_HOUR # TODO-2023-10-22: Isso limita o processamento de máximo 1 hora.
+
+	  attr_accessor :status, :uuid, :status_url, :redirect_url,
+	                :class_instance, :methods_chain, :success,
+	                :redirect_url, :failure, :_ttl
+	  attr_reader :new_record, :errors, :start_time, :end_time, :handle_async_engine
+
+	  def initialize(attrs = {})
+	    attrs.transform_keys(&:to_sym)
+	    @uuid = new_record?(attrs[:uuid]) ? "async_request:#{SecureRandom.uuid}" : attrs[:uuid]
+
+	    # INFO: Remover do repositório depois que async_request for processado
+	    # TODO-2023-10-22: Entender a relação entre número de objetos criados e
+	    # consulmo de mémoria no host onde está o redis. Definir uma estrátegia
+	    # que limite o tamanho máximo de uma instância da classe e controle do ciclo
+	    # de vida de cada instancia no banco pra ofecer melhor controle pra cada caso
+	    # de uso.
+	    destroy(30.seconds.to_i) if !new_record?(attrs[:uuid]) && attrs[:status].to_sym == :done
+
+	    # Assigners attributes
+	    assign_attributes(default_attributes.merge(attrs))
+	  end
+
+	  def valid?
+	  	@errors = []
+	  	@errors << "class_instance can't be blank." if class_instance.nil?
+
+	  	@errors.empty?
+	  end
+
+	  def attributes
+	    { 'uuid' => uuid,
+	      'status' => status,
+	      'success' => success,
+	      'failure' => failure,
+	      'methods_chain' => methods_chain,
+	      'class_instance' => class_instance,
+	      'redirect_url' => redirect_url,
+	      'start_time' => start_time,
+	      'end_time' => end_time
+	    }
+	  end
+
+	  def default_attributes
+	    {
+	    	methods_chain: [],
+	      'status' => :waiting,
+	      success: {
+	      	class_instance: 'self',
+	      	methods_chain: []
+	      },
+	      failure: {
+	      	class_instance: 'self',
+	      	methods_chain: []
+	      }
+	    }
+	  end
+
+	  def new_record?(p_uuid)
+	    return true if p_uuid.nil?
+
+	    @@config.repository_adapter.get(p_uuid).nil?
+	  end
+
+	  def id
+	    uuid
+	  end
+
+	  def self.find(p_uuid)
+	    resource = _find(p_uuid)
+	    return nil if resource.empty?
+
+	    new(resource)
+	  end
+
+	  def self._find(p_uuid)
+	    resource = @@config.repository_adapter.get(p_uuid)
+	    return nil unless resource
+
+	    unpack(resource)
+	  end
+
+	  def elapsed
+			(@end_time || Process.clock_gettime(Process::CLOCK_MONOTONIC)) - @start_time
+		end
+
+
+	  def update(attrs)
+	    assign_attributes(attrs)
+	    save
+	  end
+
+	  def reload!
+	  	assign_attributes(self.class._find(self.uuid))
+	  end
+
+	  ##
+	  # Remove request from data store. Can pass as params 
+	  # integer value for how many seconds you want remove
+	  # from data store
+	  def destroy(seconds_in = 0.seconds.to_i)
+	    return @@config.repository_adapter.del(id) if seconds_in.zero?
+
+	    self._ttl = seconds_in
+	    save
+	  end
+
+	  def save
+	  	return nil unless valid?
+	    attributes = self.class.unpack(@@config.repository_adapter.setex(uuid, (_ttl || LIVE_TIMEOUT), to_msgpack))
+	    assign_attributes(attributes)
+	  end
+
+	  def perform_async
+	  	save
+	  	handle_async_engine.perform_async(id)
+	  end
+
+	  def async_engine
+	  	handle_async_engine
+	  end
+
+	  def with_async_engine(engine_class)
+	  	@handle_async_engine = engine_class
+	  	self
+	  end
+
+	  # Serializa a intância usando o MessagePack.
+	  # Além de ser mais rápido e menor que JSON
+	  # é uma boa opção para serializar arquivos.
+	  # Ref.: https://msgpack.org/
+	  # Ref.: https://github.com/msgpack/msgpack-ruby#extension-types
+	  def to_msgpack
+	    self.class.message_pack_factory.dump(attributes.as_json)
+	  end
+
+	  def self.unpack(packer)
+	    message_pack_factory.load(packer)
+	  end
+
+	  # TODO: Desacoplar message pack factory
+	  def self.message_pack_factory
+	    factory = MessagePack::Factory.new
+
+	  	@@config.message_packer_factories.each do |fac|
+	  		factory.register_type(
+	  			fac[:first_byte],
+	  			fac[:klass],
+	  			packer: fac[:packer],
+	  			unpacker: fac[:unpacker],
+	  			recursive: true
+	  			)
+	  	end
+
+	    factory
+	  end
+
+	  def success
+	    # TODO-2023-10-22: Entender em que momento do ciclo de vida
+	    # do objeto que esse atributo é nil pra corrigir o problema
+	    # corretamente.
+	    @success&.transform_keys(&:to_sym)
+	  end
+
+	  def failure
+	    # TODO-2023-10-22: Entender em que momento do ciclo de vida
+	    # do objeto que esse atributo é nil pra corrigir o problema
+	    # corretamente.
+	    @failure&.transform_keys(&:to_sym)
+	  end
+
+	  def perform
+	    begin
+	    	@start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+	    	@@config.logger.info("Start perform worker #{self.uuid}")
+
+	    	raise "Can't update worker while it's performing" unless update(status: :processing)
+	    	
+	    	if element = MethodsChain.run_methods_chain(class_instance, methods_chain)
+	    		@@config.logger.info("successful workflow perform worker #{self.uuid}")
+
+	    		klass_after = success[:class_instance] == 'self' ? element : success[:class_instance]
+	    		methods_after = success[:methods_chain]
+
+	    		result = MethodsChain.run_methods_chain(klass_after, methods_after)
+
+	    		@end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+	        
+	        raise "Can't update worker while it's performing" unless update(status: :done)
+	        @@config.logger.info("Done perform worker #{self.uuid}")
+	        result
+	      else
+	      	@@config.logger.error("failure workflow perform worker #{self.uuid}")
+	        klass_reject_after = failure[:class_instance] == 'self' ? element : failure[:class_instance]
+	        methods_reject_after = failure[:methods_chain]
+
+	        result = MethodsChain.run_methods_chain(klass_reject_after,methods_reject_after)
+          
+          @end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+	        raise "Can't update worker while it's performing" unless update(
+	        			 status: :unprocessable_entity,
+	               errors: formated_erros_to_json(result))
+
+	        @@config.logger.error("Done perform worker #{self.uuid} with fails #{formated_erros_to_json(result)}")
+	        result
+	      end
+	    rescue StandardError => e
+        @@config.logger.fatal("Fatal perform worker #{self.uuid} with fails #{formated_erros_to_json(e.message)}")
+	    	@end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+	      update(status: :internal_server_error, errors: formated_erros_to_json(e.message))
+	      nil
+	    end
+	  end
+
+	  def formated_erros_to_json(errors)
+	    resouce = if errors.respond_to?(:map)
+	                errors.map { |title, error| { title: title, detail: error } }
+	              else
+	                [{ title: errors }]
+	              end
+
+	    resouce.map { |error| error.select { |_k, v| !v.nil? && !(v.respond_to?(:empty?) && v.empty?) } }
+	  end
+
+
+	  def errors=(value)
+	  	@errors = value
+	  end
+
+	  private
+
+	  def handle_async_engine
+	  	@handle_async_engine || @@config.async_engine
+	  end
+
+	  def assign_attributes(attrs)
+	  	attrs.each do |attribute,value|
+	  		send("#{attribute}=", value)
+	  	end
+	  end
+
+	  def start_time=(value)
+	  	@start_time = value
+	  end
+
+	  def end_time=(value)
+	  	@end_time = value
+	  end
+	end
+end

data/lib/async_request_reply/worker_in_batch.rb

@@ -0,0 +1,229 @@
+# AsyncRequestReply::WorkerInBatch - [Made for gpt]
+#
+# This class represents a batch of workers processing asynchronous requests.
+# It manages worker records, tracks their status, and provides methods to
+# manipulate and query the workers in the batch.
+#
+# Attributes:
+# - `worker_ids` [Array<String>] The UUIDs of the workers in this batch.
+# - `uuid` [String] The unique identifier for the batch.
+
+module AsyncRequestReply
+  class WorkerInBatch
+    # @private
+    class WorkerInBatchNotFound < StandardError
+      attr_accessor :uuid
+
+      def initialize(uuid)
+        @uuid = uuid
+        super
+      end
+
+      def message
+        "WorkerInBatch not found with id #{@uuid}"
+      end
+    end
+
+    # The worker UUIDs associated with this batch.
+    # @return [Array<String>] an array of worker UUIDs.
+    attr_accessor :meta, :worker_ids, :uuid, :processing, :waiting, :successes, :failures, :start_time, :end_time
+
+    # @private
+    ONE_HOUR = 3600
+
+    # @private
+    LIVE_TIMEOUT = ONE_HOUR
+
+    # @private
+    @@config = AsyncRequestReply::Config.instance
+
+    # Initializes a new batch of workers with an optional UUID.
+    #
+    # If a UUID is not provided or the UUID is invalid, a new UUID is generated.
+    #
+    # @param uuid [String, nil] The UUID of the batch. If nil, a new UUID is generated.
+    def initialize(uuid = nil)
+      @worker_ids = []
+      @meta = {}
+      @uuid = new_record?(uuid) ? "async_request_in_batch:#{SecureRandom.uuid}" : uuid
+
+      @waiting = []
+      @processing = []
+      @failures = []
+      @successes = []
+    end
+
+    # Assigns workers to the batch.
+    #
+    # The workers are saved, and their UUIDs are stored in the batch.
+    #
+    # @param workers [Array<AsyncRequestReply::Worker>] The workers to assign to the batch.
+    def workers=(workers)
+      workers.map do |worker|
+        worker.save
+        @worker_ids << worker.uuid
+      end
+    end
+
+    # Finds a `WorkerInBatch` by its UUID raise exception case not found.
+    #
+    # @param p_uuid [String] The UUID of the batch to find.
+    # @return [AsyncRequestReply::WorkerInBatch, nil] The found batch or nil if not found.
+    def self.find!(p_uuid)
+      resource = find(p_uuid)
+      raise(WorkerInBatchNotFound, p_uuid) unless resource
+
+      resource
+    end
+
+    # Finds a `WorkerInBatch` by its UUID.
+    #
+    # @param p_uuid [String] The UUID of the batch to find.
+    # @return [AsyncRequestReply::WorkerInBatch, nil] The found batch or nil if not found.
+    def self.find(p_uuid)
+      resource = _find(p_uuid)
+      return nil unless resource
+
+      instance = new(resource['uuid'])
+      instance.worker_ids = resource['worker_ids']
+      instance.start_time = resource['start_time']
+      instance.end_time = resource['end_time']
+      instance.worker_ids = resource['worker_ids']
+      instance.waiting = resource['waiting']
+      instance.processing = resource['processing']
+      instance.failures = resource['failures']
+      instance.successes = resource['successes']
+      instance.meta = resource['meta']
+      instance
+    end
+
+    # Returns the UUID of the batch.
+    #
+    # @return [String] The UUID of the batch.
+    def id
+      uuid
+    end
+
+    # Returns the UUID of the batch.
+    #
+    # @return [String] The UUID of the batch.
+    attr_reader :uuid
+
+    # Saves the current state of the batch to the repository.
+    #
+    # The batch data is serialized to JSON and stored in the repository with an
+    # expiration time of 1 hour.
+    #
+    # @return [void]
+    def save
+      # TODO-2024-11-27: Decide serializer strategy (e.g., json, message_packer).
+      @@config.repository_adapter.setex(uuid, LIVE_TIMEOUT, as_json.to_json)
+    end
+
+    # Returns the total number of workers in the batch.
+    #
+    # @return [Integer] The total count of workers in the batch.
+    def total
+      worker_ids.count
+    end
+
+    # Returns the number of processed workers (successes + failures).
+    #
+    # @return [Integer] The number of processed workers.
+    def processed
+      @successes + @failures
+    end
+
+    # Returns the elapsed time for the batch.
+    #
+    # The elapsed time is the difference between the start time and end time.
+    # If the end time is unavailable, the current process time is used.
+    #
+    # @return [Float, nil] The elapsed time in seconds or nil if start time is unavailable.
+    def elapsed
+      return nil unless @start_time
+
+      (@end_time || Process.clock_gettime(Process::CLOCK_MONOTONIC)) - @start_time
+    end
+
+    # Starts the asynchronous processing of all workers in the batch.
+    #
+    # @return [void]
+    def perform
+      # TODO: Add concurrency model.
+      @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      save
+      @waiting = worker_ids.dup
+      @waiting.size.times do
+        @processing.push(@waiting.pop)
+        save
+        worker_id = @processing.last
+        worker = AsyncRequestReply::Worker.find(worker_id)
+        worker.perform
+        worker.reload!
+        if %w[unprocessable_entity internal_server_error].include?(worker.status)
+          @failures.push(@processing.pop)
+        else
+          @successes.push(@processing.pop)
+        end
+        save
+      end
+
+      @end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      save
+    end
+
+    def perform_async
+      save
+      AsyncRequestReply::Worker.new(class_instance: AsyncRequestReply::WorkerInBatch,
+                                    methods_chain: [[:find, id],
+                                                    [:perform]]).perform_async
+    end
+
+    # Returns a JSON representation of the batch.
+    #
+    # @return [Hash] The JSON-compatible representation of the batch.
+    def as_json
+      {
+        uuid: @uuid,
+        start_time: @start_time,
+        end_time: @end_time,
+        worker_ids: @worker_ids,
+        waiting: @waiting,
+        qtd_waiting: @waiting.count,
+        processing: @processing,
+        qtd_processing: @processing.count,
+        failures: @failures,
+        qtd_fail: @failures.count,
+        successes: @successes,
+        qtd_success: @successes.count,
+        meta: @meta,
+        qtd_processed: processed.count,
+        total: total
+      }
+    end
+
+    private
+
+    # Helper method to retrieve batch data from the repository.
+    #
+    # @param p_uuid [String] The UUID of the batch.
+    # @return [Hash, nil] The parsed JSON resource or nil if not found.
+    def self._find(p_uuid)
+      resource = @@config.repository_adapter.get(p_uuid)
+      return nil unless resource
+
+      JSON.parse(resource)
+    end
+
+    # Checks if the given UUID is new (i.e., not present in the repository).
+    #
+    # @param p_uuid [String, nil] The UUID to check.
+    # @return [Boolean] True if the UUID is new, false otherwise.
+    def new_record?(p_uuid)
+      return true if p_uuid.nil?
+
+      @@config.repository_adapter.get(p_uuid).nil?
+    end
+  end
+end

data/lib/async_request_reply/workers_engine/sidekiq.rb

@@ -0,0 +1,14 @@
+require 'sidekiq'
+module AsyncRequestReply
+	module WorkersEngine
+		class Sidekiq
+			include ::Sidekiq::Worker
+		  sidekiq_options retry: 4
+
+		  def perform(async_request_id)
+				worker = ::AsyncRequestReply::Worker.find(async_request_id)
+				worker.perform
+			end
+		end
+	end
+end

data/lib/async_request_reply.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'msgpack'
+require 'active_support'
+require 'active_support/core_ext'
+
+module AsyncRequestReply
+	autoload :Config, "async_request_reply/config"
+	autoload :MethodsChain, "async_request_reply/methods_chain"
+	autoload :Worker, "async_request_reply/worker"
+	autoload :WorkerInBatch, "async_request_reply/worker_in_batch"
+	require "async_request_reply/repository_adapters/redis_repository_adapter"
+	require "async_request_reply/workers_engine/sidekiq"
+
+	# Load default configs
+	AsyncRequestReply::Config.instance
+
+	def self.configure(&block)
+		config.configure(&block)
+	end
+
+	def self.config
+		AsyncRequestReply::Config.instance
+	end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: async_request_reply
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: ruby
+authors:
+- Luiz Filipe Neves Costa, Rafael Pinheiro
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: enumerize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: redis-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Asynchronous Request-Reply pattern ruby implementation.
+email:
+- luizfilipeneves@gmail.com
+- luiz.neves@prosas.com.br
+- rafa.pinheiro.pinheiro@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/async_request_reply.rb
+- lib/async_request_reply/config.rb
+- lib/async_request_reply/methods_chain.rb
+- lib/async_request_reply/repository_adapters/abstract_repository_adapter.rb
+- lib/async_request_reply/repository_adapters/redis_repository_adapter.rb
+- lib/async_request_reply/worker.rb
+- lib/async_request_reply/worker_in_batch.rb
+- lib/async_request_reply/workers_engine/sidekiq.rb
+homepage: https://github.com/prosas/async_request_reply
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Asynchronous Request-Reply pattern ruby implementation
+test_files: []