shoryuken 7.0.0.alpha2 → 7.0.0

data/lib/shoryuken/extensions/active_job_adapter.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-# ActiveJob docs: http://edgeguides.rubyonrails.org/active_job_basics.html
-# Example adapters ref: https://github.com/rails/rails/tree/master/activejob/lib/active_job/queue_adapters
-
-require 'shoryuken'
-
-module ActiveJob
-  module QueueAdapters
-    # == Shoryuken adapter for Active Job
-    #
-    # Shoryuken ("sho-ryu-ken") is a super-efficient AWS SQS thread based message processor.
-    #
-    # Read more about Shoryuken {here}[https://github.com/ruby-shoryuken/shoryuken].
-    #
-    # To use Shoryuken set the queue_adapter config to +:shoryuken+.
-    #
-    #   Rails.application.config.active_job.queue_adapter = :shoryuken
-    class ShoryukenAdapter < ActiveJob::QueueAdapters::AbstractAdapter
-      class << self
-        def instance
-          # https://github.com/ruby-shoryuken/shoryuken/pull/174#issuecomment-174555657
-          @instance ||= new
-        end
-
-        def enqueue(job)
-          instance.enqueue(job)
-        end
-
-        def enqueue_at(job, timestamp)
-          instance.enqueue_at(job, timestamp)
-        end
-      end
-
-      # only required for Rails 7.2.x
-      def enqueue_after_transaction_commit?
-        true
-      end
-
-      def enqueue(job, options = {}) # :nodoc:
-        register_worker!(job)
-
-        job.sqs_send_message_parameters.merge! options
-
-        queue = Shoryuken::Client.queues(job.queue_name)
-        send_message_params = message queue, job
-        job.sqs_send_message_parameters = send_message_params
-        queue.send_message send_message_params
-      end
-
-      def enqueue_at(job, timestamp) # :nodoc:
-        enqueue(job, delay_seconds: calculate_delay(timestamp))
-      end
-
-      private
-
-      def calculate_delay(timestamp)
-        delay = (timestamp - Time.current.to_f).round
-        raise 'The maximum allowed delay is 15 minutes' if delay > 15.minutes
-
-        delay
-      end
-
-      def message(queue, job)
-        body = job.serialize
-        job_params = job.sqs_send_message_parameters
-
-        attributes = job_params[:message_attributes] || {}
-
-        msg = {
-          message_body: body,
-          message_attributes: attributes.merge(MESSAGE_ATTRIBUTES)
-        }
-
-        if queue.fifo?
-          # See https://github.com/ruby-shoryuken/shoryuken/issues/457 and
-          # https://github.com/ruby-shoryuken/shoryuken/pull/750#issuecomment-1781317929
-          msg[:message_deduplication_id] = Digest::SHA256.hexdigest(
-            JSON.dump(body.except('job_id', 'enqueued_at'))
-          )
-        end
-
-        msg.merge(job_params.except(:message_attributes))
-      end
-
-      def register_worker!(job)
-        Shoryuken.register_worker(job.queue_name, JobWrapper)
-      end
-
-      class JobWrapper # :nodoc:
-        include Shoryuken::Worker
-
-        shoryuken_options body_parser: :json, auto_delete: true
-
-        def perform(sqs_msg, hash)
-          receive_count = sqs_msg.attributes['ApproximateReceiveCount'].to_i
-          past_receives = receive_count - 1
-          Base.execute hash.merge({ 'executions' => past_receives })
-        end
-      end
-
-      MESSAGE_ATTRIBUTES = {
-        'shoryuken_class' => {
-          string_value: JobWrapper.to_s,
-          data_type: 'String'
-        }
-      }.freeze
-    end
-  end
-end

data/lib/shoryuken/extensions/active_job_concurrent_send_adapter.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-# ActiveJob docs: http://edgeguides.rubyonrails.org/active_job_basics.html
-# Example adapters ref: https://github.com/rails/rails/tree/master/activejob/lib/active_job/queue_adapters
-module ActiveJob
-  module QueueAdapters
-    # == Shoryuken concurrent adapter for Active Job
-    #
-    # This adapter sends messages asynchronously (ie non-blocking) and allows
-    # the caller to set up handlers for both success and failure
-    #
-    # To use this adapter, set up as:
-    #
-    # success_handler = ->(response, job, options) { StatsD.increment("#{job.class.name}.success") }
-    # error_handler = ->(err, job, options) { StatsD.increment("#{job.class.name}.failure") }
-    #
-    # adapter = ActiveJob::QueueAdapters::ShoryukenConcurrentSendAdapter.new(success_handler, error_handler)
-    #
-    # config.active_job.queue_adapter = adapter
-    class ShoryukenConcurrentSendAdapter < ShoryukenAdapter
-      def initialize(success_handler = nil, error_handler = nil)
-        @success_handler = success_handler
-        @error_handler = error_handler
-      end
-
-      def enqueue(job, options = {})
-        send_concurrently(job, options) { |f_job, f_options| super(f_job, f_options) }
-      end
-
-      def success_handler
-        @success_handler ||= ->(_send_message_response, _job, _options) { nil }
-      end
-
-      def error_handler
-        @error_handler ||= lambda { |error, job, _options|
-          Shoryuken.logger.warn("Failed to enqueue job: #{job.inspect} due to error: #{error}")
-        }
-      end
-
-      private
-
-      def send_concurrently(job, options)
-        Concurrent::Promises
-          .future(job, options) { |f_job, f_options| [yield(f_job, f_options), f_job, f_options] }
-          .then { |send_message_response, f_job, f_options| success_handler.call(send_message_response, f_job, f_options) }
-          .rescue(job, options) { |err, f_job, f_options| error_handler.call(err, f_job, f_options) }
-      end
-    end
-  end
-end

data/spec/integration/launcher_spec.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-
-RSpec.describe Shoryuken::Launcher do
-  let(:sqs_client) do
-    Aws::SQS::Client.new(
-      region: 'us-east-1',
-      endpoint: 'http://localhost:4566',
-      access_key_id: 'fake',
-      secret_access_key: 'fake'
-    )
-  end
-
-  let(:executor) do
-    # We can't use Concurrent.global_io_executor in these tests since once you
-    # shut down a thread pool, you can't start it back up. Instead, we create
-    # one new thread pool executor for each spec. We use a new
-    # CachedThreadPool, since that most closely resembles
-    # Concurrent.global_io_executor
-    Concurrent::CachedThreadPool.new auto_terminate: true
-  end
-
-  describe 'Consuming messages' do
-    before do
-      Aws.config[:stub_responses] = false
-
-      allow(Shoryuken).to receive(:launcher_executor).and_return(executor)
-
-      Shoryuken.configure_client do |config|
-        config.sqs_client = sqs_client
-      end
-
-      Shoryuken.configure_server do |config|
-        config.sqs_client = sqs_client
-      end
-
-      StandardWorker.received_messages = 0
-
-      queue = "shoryuken-travis-#{StandardWorker}-#{SecureRandom.uuid}"
-
-      Shoryuken::Client.sqs.create_queue(queue_name: queue)
-
-      Shoryuken.add_group('default', 1)
-      Shoryuken.add_queue(queue, 1, 'default')
-
-      StandardWorker.get_shoryuken_options['queue'] = queue
-
-      Shoryuken.register_worker(queue, StandardWorker)
-    end
-
-    after do
-      Aws.config[:stub_responses] = true
-
-      queue_url = Shoryuken::Client.sqs.get_queue_url(
-        queue_name: StandardWorker.get_shoryuken_options['queue']
-      ).queue_url
-
-      Shoryuken::Client.sqs.delete_queue(queue_url: queue_url)
-    end
-
-    it 'consumes as a command worker' do
-      StandardWorker.perform_async('Yo')
-
-      poll_queues_until { StandardWorker.received_messages > 0 }
-
-      expect(StandardWorker.received_messages).to eq 1
-    end
-
-    it 'consumes a message' do
-      StandardWorker.get_shoryuken_options['batch'] = false
-
-      Shoryuken::Client.queues(StandardWorker.get_shoryuken_options['queue']).send_message(message_body: 'Yo')
-
-      poll_queues_until { StandardWorker.received_messages > 0 }
-
-      expect(StandardWorker.received_messages).to eq 1
-    end
-
-    it 'consumes a batch' do
-      StandardWorker.get_shoryuken_options['batch'] = true
-
-      entries = 10.times.map { |i| { id: SecureRandom.uuid, message_body: i.to_s } }
-
-      Shoryuken::Client.queues(StandardWorker.get_shoryuken_options['queue']).send_messages(entries: entries)
-
-      # Give the messages a chance to hit the queue so they are all available at the same time
-      sleep 2
-
-      poll_queues_until { StandardWorker.received_messages > 0 }
-
-      expect(StandardWorker.received_messages).to be > 1
-    end
-
-    def poll_queues_until
-      subject.start
-
-      Timeout::timeout(10) do
-        begin
-          sleep 0.5
-        end until yield
-      end
-    ensure
-      subject.stop
-    end
-
-    class StandardWorker
-      include Shoryuken::Worker
-
-      @@received_messages = 0
-
-      shoryuken_options auto_delete: true
-
-      def perform(sqs_msg, _body)
-        @@received_messages += Array(sqs_msg).size
-      end
-
-      def self.received_messages
-        @@received_messages
-      end
-
-      def self.received_messages=(received_messages)
-        @@received_messages = received_messages
-      end
-    end
-  end
-end

data/spec/shoryuken/extensions/active_job_adapter_spec.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require 'shared_examples_for_active_job'
-require 'shoryuken/extensions/active_job_adapter'
-
-RSpec.describe ActiveJob::QueueAdapters::ShoryukenAdapter do
-  include_examples 'active_job_adapters'
-end

data/spec/shoryuken/extensions/active_job_base_spec.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_job'
-require 'shoryuken/extensions/active_job_extensions'
-require 'shoryuken/extensions/active_job_adapter'
-
-RSpec.describe ActiveJob::Base do
-  let(:queue_adapter) { ActiveJob::QueueAdapters::ShoryukenAdapter.new }
-
-  subject do
-    worker_class = Class.new(described_class)
-    Object.const_set :MyWorker, worker_class
-    worker_class.queue_adapter = queue_adapter
-    worker_class
-  end
-
-  after do
-    Object.send :remove_const, :MyWorker
-  end
-
-  describe '#perform_now' do
-    it 'allows keyword args' do
-      collaborator = double 'worker collaborator'
-      subject.send(:define_method, :perform) do |**kwargs|
-        collaborator.foo(**kwargs)
-      end
-      expect(collaborator).to receive(:foo).with(foo: 'bar')
-      subject.perform_now foo: 'bar'
-    end
-  end
-
-  describe '#perform_later' do
-    it 'calls enqueue on the adapter with the expected job' do
-      expect(queue_adapter).to receive(:enqueue) do |job|
-        expect(job.arguments).to eq([1, 2])
-      end
-
-      subject.perform_later 1, 2
-    end
-
-    it 'passes message_group_id to the queue_adapter' do
-      expect(queue_adapter).to receive(:enqueue) do |job|
-        expect(job.sqs_send_message_parameters[:message_group_id]).to eq('group-2')
-      end
-
-      subject.set(message_group_id: 'group-2').perform_later 1, 2
-    end
-
-    it 'passes message_deduplication_id to the queue_adapter' do
-      expect(queue_adapter).to receive(:enqueue) do |job|
-        expect(job.sqs_send_message_parameters[:message_deduplication_id]).to eq('dedupe-id')
-      end
-
-      subject.set(message_deduplication_id: 'dedupe-id').perform_later 1, 2
-    end
-
-    it 'passes message_attributes to the queue_adapter' do
-      message_attributes = {
-        'custom_tracing_id' => {
-          string_value: 'value',
-          data_type: 'String'
-        }
-      }
-      expect(queue_adapter).to receive(:enqueue) do |job|
-        expect(job.sqs_send_message_parameters[:message_attributes]).to eq(message_attributes)
-      end
-
-      subject.set(message_attributes: message_attributes).perform_later 1, 2
-    end
-
-    it 'passes message_system_attributes to the queue_adapter' do
-      message_system_attributes = {
-        'AWSTraceHeader' => {
-          string_value: 'trace_id',
-          data_type: 'String'
-        }
-      }
-      expect(queue_adapter).to receive(:enqueue) do |job|
-        expect(job.sqs_send_message_parameters[:message_system_attributes]).to eq(message_system_attributes)
-      end
-
-      subject.set(message_system_attributes: message_system_attributes).perform_later 1, 2
-    end
-  end
-end