shoryuken 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7391a170e4f76601238417e61b88861951bc6c73
-  data.tar.gz: 8983d19ef10bea4723533a12b23b74ca55562baf
+  metadata.gz: 3afa1e42164a3fc885caf45222d317ac77692c3b
+  data.tar.gz: 9abfa8e2c9ed9b4540bbb422fba35a3f00591364
 SHA512:
-  metadata.gz: 87a30b0002f3eaf8a62fd9f76e938fb57a5fcecc829c6a3cf8fdb7c4d1ab3388001fc460b92d59d3ae2762b441f447141bc92c136dbf6fb8730820c101df2dc0
-  data.tar.gz: 79f4d02f0dac764f23d07f8d27711c70b0cb97543cd410c2436300ff3e633a625de290caedf3746366b77d6c9b737c0c0138d000e2d610dab715267a40e74bb3
+  metadata.gz: 35934726404b3d5454b1bc97875d3ba8934d2ef4efa4a354dbff97af95959c647757259ffc6fefc53a8ffaab5c1cfeffad73d79aff50a3575f5e65d39cbbb553
+  data.tar.gz: 6cafc6fbfd06fff62541acc41169877440454eba4afb1688728bbd69330ed53fa9a62d1c28b2b9a057de853952cff26d537d013747a8cc5b6c47a8b637f3c1f2

data/README.md

@@ -10,7 +10,7 @@ Shoryuken _sho-ryu-ken_ is a super efficient [AWS SQS](https://aws.amazon.com/sq
 
 ### Load balancing
 
-Yeah, Shoryuken load balances the messages consumption, for example:
+Yeah, Shoryuken load balances the messages consumption!
 
 Given this configuration:
 
@@ -18,19 +18,21 @@ Given this configuration:
 concurrency: 25,
 delay: 25,
 queues:
-  - [shoryuken, 6]
-  - [uppercut, 2]
-  - [sidekiq, 1]
+  - [high_priority, 6]
+  - [default, 2]
+  - [low_priority, 1]
 ```
 
-And supposing all the queues are full of messages, the configuration above will make Shoryuken to process "shoryuken" 3 times more than "uppercut" and 6 times more than "sidekiq",
-splitting the work among the 25 available processors.
+And supposing all the queues are full of messages, the configuration above will make Shoryuken to process `high_priority` 3 times more than `default` and 6 times more than `low_priority`,
+splitting the work among the `concurrency: 25` available processors.
 
-If the "shoryuken" queue gets empty, Shoryuken will keep using the 25 processors, but only to process "uppercut" (2 times more than "sidekiq") and "sidekiq".
+If `high_priority` gets empty, Shoryuken will keep using the 25 processors, but only to process `default` (2 times more than `low_priority`) and `low_priority`.
 
-If the "shoryuken" queue gets a new message, Shoryuken will smoothly increase back the "shoryuken" weight one by one until it reaches the weight of 5 again.
+If `high_priority` receives a new message, Shoryuken will smoothly increase back the `high_priority` weight one by one until it reaches the weight of 6 again, which is the maximum configured for `high_priority`.
 
-If all queues get empty, all processors will be changed to the waiting state and the queues will be checked every `delay: 25`. If any queue gets a new message, Shoryuken will bring back the processors one by one to the ready state.
+If all queues get empty, all processors will be changed to the waiting state and the queues will be checked every `delay: 25`. If any queue receives a new message, Shoryuken will start processing again.
+
+*You can set `delay: 0` to continuously check the queues without pausing even if they are empty.*
 
 ### Fetch in batches
 
@@ -42,6 +44,10 @@ Add this line to your application's Gemfile:
 
     gem 'shoryuken'
 
+**Require Shoryuken from GitHub to get the latest updates:**
+
+    gem 'shoryuken', github: 'phstc/shoryuken', branch: 'master'
+
 And then execute:
 
     $ bundle
@@ -55,24 +61,51 @@ Or install it yourself as:
 ### Worker class
 
 ```ruby
-class HelloWorker
+class MyWorker
   include Shoryuken::Worker
 
-  shoryuken_options queue: 'hello', delete: true
-  # shoryuken_options queue: ->{ "#{ENV['environment']_hello" }, delete: true
+  shoryuken_options queue: 'default', delete: true
+  # shoryuken_options queue: ->{ "#{ENV['environment']_default" }
+
+  # shoryuken_options body_parser: :json
+  # shoryuken_options body_parser: ->(sqs_msg){ REXML::Document.new(sqs_msg.body) }
+  # shoryuken_options body_parser: JSON
 
-  def perform(sqs_msg)
-    puts "Hello #{sqs_msg.body}"
+  def perform(sqs_msg, body)
+    puts body
   end
 end
 ```
 
+[Check the Worker options documention](https://github.com/phstc/shoryuken/wiki/Worker-options).
+
 ### Sending a message
 
 ```ruby
-Shoryuken::Client.queues('hello').send_message('Pablo')
+MyWorker.perform_async('Pablo')
+# or
+Shoryuken::Client.queues('default').send_message('Pablo')
+
+# delaying a message
+MyWorker.perform_async('Pablo', delay_seconds: 60)
+# or
+Shoryuken::Client.queues('default').send_message('Pablo', delay_seconds: 60)
+```
+
+### Midleware
+
+```ruby
+class MyMiddleware
+  def call(worker_instance, queue, sqs_msg, body)
+    puts 'Before work'
+    yield
+    puts 'After work'
+  end
+end
 ```
 
+[Check the Middleware documentation](https://github.com/phstc/shoryuken/wiki/Middleware).
+
 ### Configuration
 
 Sample configuration file `shoryuken.yml`.
@@ -90,9 +123,9 @@ aws:
 concurrency: 25,  # The number of allocated threads to process messages. Default 25
 delay: 25,        # The delay in seconds to pause a queue when it's empty. Default 0
 queues:
-  - [shoryuken, 6]
-  - [uppercut, 2]
-  - [sidekiq, 1]
+  - [high_priority, 6]
+  - [default, 2]
+  - [low_priority, 1]
 ```
 
 ### Start Shoryuken
@@ -120,24 +153,6 @@ shoryuken [options]
     ...
 ```
 
-### Middleware
-
-```ruby
-class MyServerHook
-  def call(worker_instance, queue, sqs_msg)
-    puts 'Before work'
-    yield
-    puts 'After work'
-  end
-end
-
-Shoryuken.configure_server do |config|
-  config.server_middleware do |chain|
-    chain.add MyServerHook
-    # chain.remove MyServerHook
-  end
-end
-```
 
 ## More Information
 

data/Rakefile

@@ -22,7 +22,7 @@ task :console do
   Pry.start
 end
 
-desc 'Push test messages to shoryuken, uppercut and sidekiq'
+desc 'Push test messages to high_priority, default and low_priority'
 task :push_test, :size do |t, args|
   require 'yaml'
   require 'shoryuken'
@@ -31,13 +31,17 @@ task :push_test, :size do |t, args|
 
   AWS.config(config['aws'])
 
+  Shoryuken::Client.sqs.queues.create('default')
+  Shoryuken::Client.sqs.queues.create('high_priority')
+  Shoryuken::Client.sqs.queues.create('low_priority')
+
   (args[:size] || 1).to_i.times.map do |i|
     Thread.new do
-      Shoryuken::Client.queues('shoryuken').send_message("shoryuken #{i}")
-      Shoryuken::Client.queues('uppercut').send_message("uppercut #{i}")
-      Shoryuken::Client.queues('sidekiq').send_message("sidekiq #{i}")
+      puts "Pushing test ##{i}"
 
-      puts "Push test ##{i + 1}"
+      Shoryuken::Client.queues('high_priority').send_message("test #{i}")
+      Shoryuken::Client.queues('default').send_message("test #{i}")
+      Shoryuken::Client.queues('low_priority').send_message("test #{i}")
     end
   end.each &:join
 end

data/examples/all.rb

@@ -1,5 +1,5 @@
 $stdout.sync = true
 
-require_relative 'shoryuken_worker'
-require_relative 'uppercut_worker'
-require_relative 'sidekiq_worker'
+require_relative 'high_priority_worker'
+require_relative 'default_worker'
+require_relative 'low_priority_worker'

data/examples/default_worker.rb

@@ -0,0 +1,9 @@
+class DefaultWorker
+  include Shoryuken::Worker
+
+  shoryuken_options queue: 'default', delete: true, body_parser: ->(sqs_msg){ "new body: #{sqs_msg.body}" }
+
+  def perform(sqs_msg, body)
+    puts "DefaultWorker: '#{body}'"
+  end
+end

data/examples/high_priority_worker.rb

@@ -0,0 +1,9 @@
+class HighPriorityWorker
+  include Shoryuken::Worker
+
+  shoryuken_options queue: 'high_priority', delete: true
+
+  def perform(sqs_msg, body)
+    puts "HighPriorityWorker: '#{body}'"
+  end
+end

data/examples/low_priority_worker.rb

@@ -0,0 +1,11 @@
+class LowPriorityWorker
+  include Shoryuken::Worker
+
+  shoryuken_options queue: 'low_priority', delete: true, batch: true
+
+  def perform(sqs_msgs, bodies)
+    bodies.each_with_index do |body, index|
+      puts "LowPriorityWorker (#{index}): '#{body}'"
+    end
+  end
+end

data/lib/shoryuken.rb

@@ -9,8 +9,8 @@ require 'shoryuken/client'
 require 'shoryuken/worker'
 require 'shoryuken/logging'
 require 'shoryuken/middleware/chain'
-require 'shoryuken/middleware/server/delete'
-require 'shoryuken/middleware/server/logging'
+require 'shoryuken/middleware/server/auto_delete'
+require 'shoryuken/middleware/server/timing'
 
 module Shoryuken
   DEFAULTS = {
@@ -64,8 +64,8 @@ module Shoryuken
 
   def self.default_server_middleware
     Middleware::Chain.new do |m|
-      m.add Middleware::Server::Logging
-      m.add Middleware::Server::Delete
+      m.add Middleware::Server::Timing
+      m.add Middleware::Server::AutoDelete
       # TODO m.add Middleware::Server::RetryJobs
     end
   end

data/lib/shoryuken/cli.rb

@@ -16,7 +16,7 @@ module Shoryuken
     def run(args)
       self_read, self_write = IO.pipe
 
-      %w(INT TERM USR1 USR2 TTIN).each do |sig|
+      %w[INT TERM USR1 USR2 TTIN].each do |sig|
         trap sig do
           self_write.puts(sig)
         end
@@ -24,11 +24,12 @@ module Shoryuken
 
       setup_options(args)
       initialize_logger
+      require_workers
       validate!
+      patch_deprecated_workers!
       daemonize
       write_pid
       load_celluloid
-      require_workers
 
       require 'shoryuken/launcher'
       @launcher = Shoryuken::Launcher.new
@@ -144,7 +145,7 @@ module Shoryuken
 
       @parser.banner = 'shoryuken [options]'
       @parser.on_tail '-h', '--help', 'Show help' do
-        Shoryuken.logger.info @parser
+        logger.info @parser
         exit 1
       end
       @parser.parse!(argv)
@@ -152,22 +153,22 @@ module Shoryuken
     end
 
     def handle_signal(sig)
-      Shoryuken.logger.info "Got #{sig} signal"
+      logger.info "Got #{sig} signal"
 
       case sig
       when 'USR1'
-        Shoryuken.logger.info "Received USR1, will soft shutdown down"
+        logger.info "Received USR1, will soft shutdown down"
 
         launcher.stop
 
         exit 0
       when 'TTIN'
         Thread.list.each do |thread|
-          Shoryuken.logger.info "Thread TID-#{thread.object_id.to_s(36)} #{thread['label']}"
+          logger.info "Thread TID-#{thread.object_id.to_s(36)} #{thread['label']}"
           if thread.backtrace
-            Shoryuken.logger.info thread.backtrace.join("\n")
+            logger.info thread.backtrace.join("\n")
           else
-            Shoryuken.logger.info "<no backtrace available>"
+            logger.info "<no backtrace available>"
           end
         end
 
@@ -175,9 +176,9 @@ module Shoryuken
         busy   = launcher.manager.instance_variable_get(:@busy).size
         queues = launcher.manager.instance_variable_get(:@queues)
 
-        Shoryuken.logger.info "Ready: #{ready}, Busy: #{busy}, Active Queues: #{unparse_queues(queues)}"
+        logger.info "Ready: #{ready}, Busy: #{busy}, Active Queues: #{unparse_queues(queues)}"
       else
-        Shoryuken.logger.info "Received #{sig}, will shutdown down"
+        logger.info "Received #{sig}, will shutdown down"
 
         raise Interrupt
       end
@@ -210,13 +211,18 @@ module Shoryuken
     end
 
     def validate!
+      raise ArgumentError, 'No queues supplied' if Shoryuken.queues.empty?
+
+      if queue_without_worker = Shoryuken.queues.find { |queue| Shoryuken.workers[queue].nil? }
+        raise ArgumentError, "No worker supplied for #{queue_without_worker}"
+      end
+
       if Shoryuken.options[:aws][:access_key_id].nil? && Shoryuken.options[:aws][:secret_access_key].nil?
         if ENV['AWS_ACCESS_KEY_ID'].nil? && ENV['AWS_SECRET_ACCESS_KEY'].nil?
           raise ArgumentError, 'No AWS credentials supplied'
         end
       end
 
-
       initialize_aws
 
       Shoryuken.queues.uniq.each do |queue|
@@ -229,8 +235,6 @@ module Shoryuken
           raise
         end
       end
-
-      raise ArgumentError, 'No queues supplied' if Shoryuken.queues.empty?
     end
 
     def initialize_aws
@@ -250,5 +254,21 @@ module Shoryuken
     def parse_queue(queue, weight = nil)
       [weight.to_i, 1].max.times { Shoryuken.queues << queue }
     end
+
+    def patch_deprecated_workers!
+      Shoryuken.workers.each do |queue, worker_class|
+        if worker_class.instance_method(:perform).arity == 1
+          logger.warn "[DEPRECATION] #{worker_class.name}#perform(sqs_msg) is deprecated. Please use #{worker_class.name}#perform(sqs_msg, body)"
+
+          worker_class.class_eval do
+            alias_method :deprecated_perform, :perform
+
+            def perform(sqs_msg, body = nil)
+              deprecated_perform(sqs_msg)
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/shoryuken/client.rb

@@ -16,6 +16,10 @@ module Shoryuken
         queues(queue).receive_message(Hash(options))
       end
 
+      def send_message(queue, body, options = {})
+        queues(queue).send_message(body, options)
+      end
+
       def sqs
         @sqs ||= AWS::SQS.new
       end

data/lib/shoryuken/launcher.rb

@@ -34,7 +34,7 @@ module Shoryuken
 
     def actor_died(actor, reason)
       return if @done
-      Shoryuken.logger.warn 'Shoryuken died due to the following error, cannot recover, process exiting'
+      logger.warn 'Shoryuken died due to the following error, cannot recover, process exiting'
       exit 1
     end
   end

data/lib/shoryuken/middleware/chain.rb

@@ -101,11 +101,29 @@ module Shoryuken
       def initialize(klass, *args)
         @klass = klass
         @args  = args
+
+        patch_deprecated_middleware!(klass)
       end
 
       def make_new
         @klass.new(*@args)
       end
+
+      private
+
+      def patch_deprecated_middleware!(klass)
+        if klass.instance_method(:call).arity == 3
+          Shoryuken.logger.warn "[DEPRECATION] #{klass.name}#call(worker_instance, queue, sqs_msg) is deprecated. Please use #{klass.name}#call(worker_instance, queue, sqs_msg, body)"
+
+          klass.class_eval do
+            alias_method :deprecated_call, :call
+
+            def call(worker_instance, queue, sqs_msg, body = nil, &block)
+              deprecated_call(worker_instance, queue, sqs_msg, &block)
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/shoryuken/middleware/server/auto_delete.rb

@@ -0,0 +1,18 @@
+module Shoryuken
+  module Middleware
+    module Server
+      class AutoDelete
+
+        def call(worker, queue, sqs_msg, body)
+          yield
+
+          # I'm still deciding, but `auto_delete` will be probably deprecated soon
+          delete = worker.class.get_shoryuken_options['delete'] || worker.class.get_shoryuken_options['auto_delete']
+
+          Shoryuken::Client.queues(queue).batch_delete(*Array(sqs_msg)) if delete
+        end
+      end
+    end
+  end
+end
+

data/lib/shoryuken/middleware/server/{logging.rb → timing.rb}

@@ -1,15 +1,15 @@
 module Shoryuken
   module Middleware
     module Server
-      class Logging
+      class Timing
         include Util
 
-        def call(worker, queue, sqs_msg)
+        def call(worker, queue, sqs_msg, body)
           Shoryuken::Logging.with_context("#{worker.class.to_s}/#{queue}/#{sqs_msg.id}") do
             begin
               started_at = Time.now
 
-              logger.info { "started at #{started_at}" }
+              logger.info "started at #{started_at}"
 
               yield
 
@@ -19,9 +19,9 @@ module Shoryuken
                 logger.warn "exceeded the queue visibility timeout by #{total_time - (timeout * 1000)} ms"
               end
 
-              logger.info { "completed in: #{total_time} ms" }
+              logger.info "completed in: #{total_time} ms"
             rescue => e
-              logger.info { "failed in: #{elapsed(started_at)} ms" }
+              logger.info "failed in: #{elapsed(started_at)} ms"
               raise e
             end
           end

data/lib/shoryuken/processor.rb

@@ -1,4 +1,4 @@
-require 'multi_json'
+require 'json'
 
 module Shoryuken
   class Processor
@@ -10,19 +10,46 @@ module Shoryuken
     end
 
     def process(queue, sqs_msg)
-      if worker_class = Shoryuken.workers[queue]
-        defer do
-          worker = worker_class.new
+      worker_class = Shoryuken.workers[queue]
+      defer do
+        body = get_body(worker_class, sqs_msg)
 
-          Shoryuken.server_middleware.invoke(worker, queue, sqs_msg) do
-            worker.perform(sqs_msg)
-          end
+        worker = worker_class.new
+
+        Shoryuken.server_middleware.invoke(worker, queue, sqs_msg, body) do
+          worker.perform(sqs_msg, body)
         end
-      else
-        logger.error "Worker not found for queue '#{queue}'"
       end
 
       @manager.async.processor_done(queue, current_actor)
     end
+
+    private
+
+    def get_body(worker_class, sqs_msg)
+      if sqs_msg.is_a? Array
+        sqs_msg.map { |m| parse_body(worker_class, m) }
+      else
+        parse_body(worker_class, sqs_msg)
+      end
+    end
+
+    def parse_body(worker_class, sqs_msg)
+      body_parser = worker_class.get_shoryuken_options['body_parser']
+
+      case body_parser
+      when :json
+        JSON.parse(sqs_msg.body)
+      when Proc
+        body_parser.call(sqs_msg)
+      when :text, nil
+        sqs_msg.body
+      else
+        body_parser.parse(sqs_msg.body) if body_parser.respond_to?(:parse) # i.e. JSON.parse(...)
+      end
+    rescue => e
+      logger.error "Error parsing the message body: #{e.message}\nbody_parser: #{body_parser}\nsqs_msg.body: #{sqs_msg.body}"
+      nil
+    end
   end
 end

data/lib/shoryuken/util.rb

@@ -13,6 +13,7 @@ module Shoryuken
     end
 
     def elapsed(started_at)
+      # elapsed in ms
       (Time.now - started_at) * 1000
     end
 

data/lib/shoryuken/version.rb

@@ -1,3 +1,3 @@
 module Shoryuken
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/shoryuken/worker.rb

@@ -5,6 +5,10 @@ module Shoryuken
     end
 
     module ClassMethods
+      def perform_async(body, options = {})
+        Shoryuken::Client.send_message(get_shoryuken_options['queue'], body, options)
+      end
+
       def shoryuken_options(opts = {})
         @shoryuken_options = get_shoryuken_options.merge(stringify_keys(Hash(opts)))
         queue = @shoryuken_options['queue']

data/shoryuken.gemspec

@@ -24,5 +24,4 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "aws-sdk"
   spec.add_dependency "celluloid"
-  spec.add_dependency "multi_json"
 end

data/spec/integration/launcher_spec.rb

@@ -11,20 +11,28 @@ describe Shoryuken::Launcher do
 
       subject.run
 
-      $received_messages = 0
+      ShoryukenWorker.received_messages = 0
     end
 
-    after do
-      subject.stop
-    end
+    after { subject.stop }
 
     class ShoryukenWorker
       include Shoryuken::Worker
 
+      @@received_messages = 0
+
       shoryuken_options queue: 'shoryuken', delete: true
 
-      def perform(sqs_msg)
-        $received_messages = Array(sqs_msg).size
+      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
 
@@ -34,11 +42,11 @@ describe Shoryuken::Launcher do
       Shoryuken::Client.queues('shoryuken').send_message('Yo')
 
       10.times do
-        break if $received_messages > 0
+        break if ShoryukenWorker.received_messages > 0
         sleep 0.2
       end
 
-      expect($received_messages).to eq 1
+      expect(ShoryukenWorker.received_messages).to eq 1
     end
 
     it 'consumes a batch' do
@@ -47,12 +55,12 @@ describe Shoryuken::Launcher do
       Shoryuken::Client.queues('shoryuken').batch_send *(['Yo'] * 10)
 
       10.times do
-        break if $received_messages > 0
+        break if ShoryukenWorker.received_messages > 0
         sleep 0.2
       end
 
       # the fetch result is uncertain, should be greater than 1, but hard to tell the exact size
-      expect($received_messages).to be > 1
+      expect(ShoryukenWorker.received_messages).to be > 1
     end
   end
 end

data/spec/shoryuken/client_spec.rb

@@ -21,6 +21,20 @@ describe Shoryuken::Client do
     end
   end
 
+  describe '.send_message' do
+    it 'enqueues a message' do
+      expect(sqs_queue).to receive(:send_message).with('test', {})
+
+      described_class.send_message(queue, 'test')
+    end
+
+    it 'enqueues a message with options' do
+      expect(sqs_queue).to receive(:send_message).with('test2', delay_seconds: 60)
+
+      described_class.send_message(queue, 'test2', delay_seconds: 60)
+    end
+  end
+
   describe '.visibility_timeout' do
     it 'memoizes visibility_timeout' do
       expect(sqs_queue).to receive(:visibility_timeout).once.and_return(30)

data/spec/shoryuken/fetcher_spec.rb

@@ -5,8 +5,8 @@ require 'shoryuken/fetcher'
 describe Shoryuken::Fetcher do
   let(:manager)   { double Shoryuken::Manager }
   let(:sqs_queue) { double 'sqs_queue' }
-  let(:queue)     { 'shoryuken2' }
-  let(:sqs_msg)   { double 'SQS msg'}
+  let(:queue)     { 'default' }
+  let(:sqs_msg)   { double AWS::SQS::ReceivedMessage, id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e', body: 'test' }
 
   subject { described_class.new(manager) }
 
@@ -16,14 +16,6 @@ describe Shoryuken::Fetcher do
   end
 
 
-  class Shoryuken2Worker
-    include Shoryuken::Worker
-
-    shoryuken_options queue: 'shoryuken2'
-
-    def perform(sqs_msg); end
-  end
-
   describe '#fetch' do
     it 'calls pause when no message' do
       allow(sqs_queue).to receive(:receive_message).with(limit: 1).and_return([])
@@ -45,7 +37,7 @@ describe Shoryuken::Fetcher do
     end
 
     it 'assigns messages in batch' do
-      Shoryuken2Worker.get_shoryuken_options['batch'] = true
+      TestWorker.get_shoryuken_options['batch'] = true
 
       allow(sqs_queue).to receive(:receive_message).with(limit: described_class::FETCH_LIMIT).and_return(sqs_msg)
 

data/spec/shoryuken/middleware/chain_spec.rb

@@ -20,7 +20,7 @@ describe Shoryuken::Middleware::Chain do
     expect(CustomMiddleware).to eq subject.entries.last.klass
   end
 
-  it 'executes middleware' do
+  it 'invokes a middleware' do
     recorder = []
     subject.add CustomMiddleware, 'Pablo', recorder
 
@@ -31,8 +31,7 @@ describe Shoryuken::Middleware::Chain do
   end
 
   class NonYieldingMiddleware
-    def call(*args)
-    end
+    def call(*args); end
   end
 
   it 'allows middleware to abruptly stop processing rest of chain' do
@@ -45,4 +44,26 @@ describe Shoryuken::Middleware::Chain do
     expect(final_action).to eq nil
     expect(recorder).to eq []
   end
+
+  class DeprecatedMiddleware
+    def call(worker_instance, queue, sqs_msg)
+      @@success = true
+    end
+
+    def self.success?
+      !!@@success
+    end
+  end
+
+  it 'patches deprecated middleware' do
+    subject.clear
+
+    expect(Shoryuken.logger).to receive(:warn).with("[DEPRECATION] DeprecatedMiddleware#call(worker_instance, queue, sqs_msg) is deprecated. Please use DeprecatedMiddleware#call(worker_instance, queue, sqs_msg, body)")
+
+    subject.add DeprecatedMiddleware
+
+    subject.invoke TestWorker, 'test', double('SQS msg', body: 'test'), 'test'
+
+    expect(DeprecatedMiddleware.success?).to eq true
+  end
 end

data/spec/shoryuken/middleware/server/auto_delete_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Shoryuken::Middleware::Server::AutoDelete do
+  let(:sqs_msg)   { double AWS::SQS::ReceivedMessage, id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e', body: 'test' }
+  let(:queue)     { 'default' }
+  let(:sqs_queue) { double AWS::SQS::Queue }
+
+  before do
+    allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+  end
+
+  it 'deletes a message' do
+    TestWorker.get_shoryuken_options['delete'] = true
+
+    expect(sqs_queue).to receive(:batch_delete).with(sqs_msg)
+
+    subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) {}
+  end
+
+  it 'deletes a batch' do
+    TestWorker.get_shoryuken_options['delete'] = true
+
+    sqs_msg2 = double 'SQS msg', body: 'test'
+    sqs_msg3 = double 'SQS msg', body: 'test'
+
+    sqs_msgs = [sqs_msg, sqs_msg2, sqs_msg3]
+
+    expect(sqs_queue).to receive(:batch_delete).with(*sqs_msgs)
+
+    subject.call(TestWorker.new, queue, sqs_msgs, [sqs_msg.body, sqs_msg2.body, sqs_msg3.body]) {}
+  end
+
+  it 'does not delete a message' do
+    TestWorker.get_shoryuken_options['delete'] = false
+
+    expect(sqs_queue).to_not receive(:batch_delete)
+
+    subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) {}
+  end
+
+  context 'when exception' do
+    it 'does not delete a message' do
+      expect(sqs_queue).to_not receive(:batch_delete)
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise }
+      }.to raise_error
+    end
+  end
+end

data/spec/shoryuken/middleware/server/timing_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Shoryuken::Middleware::Server::Timing do
+  let(:sqs_msg) { double AWS::SQS::ReceivedMessage, id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e', body: 'test' }
+  let(:queue)   { 'default' }
+
+  xit 'logs timing' do
+    expect(Shoryuken.logger).to receive(:info).with(/started at/)
+    expect(Shoryuken.logger).to receive(:info).with(/completed in/)
+
+    subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) {}
+  end
+
+  context 'when exceeded the `visibility_timeout`' do
+    it 'logs exceeded' do
+      allow(Shoryuken::Client).to receive(:visibility_timeout).and_return(60)
+      allow(subject).to receive(:elapsed).and_return(120000)
+
+      expect(Shoryuken.logger).to receive(:info).with(/started at/)
+      expect(Shoryuken.logger).to receive(:info).with(/completed in/)
+      expect(Shoryuken.logger).to receive(:warn).with('exceeded the queue visibility timeout by 60000 ms')
+
+      subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) {}
+    end
+  end
+
+  context 'when exception' do
+    it 'logs failed in' do
+      expect(Shoryuken.logger).to receive(:info).with(/started at/)
+      expect(Shoryuken.logger).to receive(:info).with(/failed in/)
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise }
+      }.to raise_error
+    end
+  end
+end

data/spec/shoryuken/processor_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 require 'shoryuken/processor'
+require 'shoryuken/manager'
 
 describe Shoryuken::Processor do
-  let(:manager)   { double Shoryuken::Manager }
-  let(:sqs_queue) { double 'Queue', visibility_timeout: 30 }
-  let(:queue)     { 'yo' }
-  let(:sqs_msg)   { double AWS::SQS::ReceivedMessage, id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e' }
+  let(:manager)   { double Shoryuken::Manager, processor_done: nil }
+  let(:sqs_queue) { double AWS::SQS::Queue, visibility_timeout: 30 }
+  let(:queue)     { 'default' }
+  let(:sqs_msg)   { double AWS::SQS::ReceivedMessage, id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e', body: 'test' }
 
   subject { described_class.new(manager) }
 
@@ -15,27 +16,84 @@ describe Shoryuken::Processor do
   end
 
   describe '#process' do
-    class YoWorker
-      include Shoryuken::Worker
+    it 'parses the body into JSON' do
+      TestWorker.get_shoryuken_options['body_parser'] = :json
 
-      shoryuken_options queue: 'yo'
+      body = { 'test' => 'hi' }
 
-      def perform(sqs_msg); end
+      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, body)
+
+      allow(sqs_msg).to receive(:body).and_return(JSON.dump(body))
+
+      subject.process(queue, sqs_msg)
     end
 
-    it 'skips when worker not found' do
-      queue = 'notfound'
+    it 'parses the body calling the proc' do
+      TestWorker.get_shoryuken_options['body_parser'] = Proc.new { |sqs_msg| "*#{sqs_msg.body}*" }
 
-      expect(manager).to receive(:processor_done).with(queue, subject)
+      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, '*test*')
+
+      allow(sqs_msg).to receive(:body).and_return('test')
+
+      subject.process(queue, sqs_msg)
+    end
+
+    it 'parses the body as text' do
+      TestWorker.get_shoryuken_options['body_parser'] = :text
+
+      body = 'test'
+
+      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, body)
+
+      allow(sqs_msg).to receive(:body).and_return(body)
+
+      subject.process(queue, sqs_msg)
+    end
+
+    it 'parses calling `.parse`' do
+      TestWorker.get_shoryuken_options['body_parser'] = JSON
+
+      body = { 'test' => 'hi' }
 
-      expect(sqs_msg).to_not receive(:delete)
+      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, body)
+
+      allow(sqs_msg).to receive(:body).and_return(JSON.dump(body))
 
       subject.process(queue, sqs_msg)
     end
 
+    context 'when parse errors' do
+      it 'does not fail' do
+        TestWorker.get_shoryuken_options['body_parser'] = :json
+
+        expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, nil)
+
+        allow(sqs_msg).to receive(:body).and_return('invalid json')
+
+        expect(subject.logger).to receive(:error).with("Error parsing the message body: 757: unexpected token at 'invalid json'\nbody_parser: json\nsqs_msg.body: invalid json")
+
+        subject.process(queue, sqs_msg)
+      end
+    end
+
+    context 'when `object_type: nil`' do
+      it 'parses the body as text' do
+        TestWorker.get_shoryuken_options['body_parser'] = nil
+
+        body = 'test'
+
+        expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, body)
+
+        allow(sqs_msg).to receive(:body).and_return(body)
+
+        subject.process(queue, sqs_msg)
+      end
+    end
+
     context 'when custom middleware' do
       class WorkerCalledMiddleware
-        def call(worker, queue, sqs_msg)
+        def call(worker, queue, sqs_msg, body)
+          # called is defined with `allow(...).to receive(...)`
           worker.called(sqs_msg, queue)
           yield
         end
@@ -60,33 +118,33 @@ describe Shoryuken::Processor do
       it 'invokes middleware' do
         expect(manager).to receive(:processor_done).with(queue, subject)
 
-        expect_any_instance_of(YoWorker).to receive(:perform).with(sqs_msg)
-        expect_any_instance_of(YoWorker).to receive(:called).with(sqs_msg, queue)
+        expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, sqs_msg.body)
+        expect_any_instance_of(TestWorker).to receive(:called).with(sqs_msg, queue)
 
         subject.process(queue, sqs_msg)
       end
     end
 
     it 'performs with delete' do
-      YoWorker.get_shoryuken_options['delete'] = true
+      TestWorker.get_shoryuken_options['delete'] = true
 
       expect(manager).to receive(:processor_done).with(queue, subject)
 
-      expect_any_instance_of(YoWorker).to receive(:perform).with(sqs_msg)
+      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, sqs_msg.body)
 
-      expect(sqs_msg).to receive(:delete)
+      expect(sqs_queue).to receive(:batch_delete).with(sqs_msg)
 
       subject.process(queue, sqs_msg)
     end
 
     it 'performs without delete' do
-      YoWorker.get_shoryuken_options['delete'] = false
+      TestWorker.get_shoryuken_options['delete'] = false
 
       expect(manager).to receive(:processor_done).with(queue, subject)
 
-      expect_any_instance_of(YoWorker).to receive(:perform).with(sqs_msg)
+      expect_any_instance_of(TestWorker).to receive(:perform).with(sqs_msg, sqs_msg.body)
 
-      expect(sqs_msg).to_not receive(:delete)
+      expect(sqs_queue).to_not receive(:batch_delete)
 
       subject.process(queue, sqs_msg)
     end

data/spec/shoryuken/worker_spec.rb

@@ -1,28 +1,42 @@
 require 'spec_helper'
 
 describe 'Shoryuken::Worker' do
+  let(:sqs_queue) { double 'SQS Queue' }
+  let(:queue)     { 'default' }
 
-  describe '.shoryuken_options' do
-    it 'registers the worker' do
-      class UppercutWorker
-        include Shoryuken::Worker
+  before do
+    allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+  end
 
-        shoryuken_options queue: 'uppercut'
-      end
+  describe '.perform_async' do
+    it 'enqueues a message' do
+      expect(sqs_queue).to receive(:send_message).with('message', {})
+
+      TestWorker.perform_async('message')
+    end
 
-      expect(Shoryuken.workers['uppercut']).to eq UppercutWorker
+    it 'enqueues a message with options' do
+      expect(sqs_queue).to receive(:send_message).with('delayed message', delay_seconds: 60)
+
+      TestWorker.perform_async('delayed message', delay_seconds: 60)
+    end
+  end
+
+  describe '.shoryuken_options' do
+    it 'registers a worker' do
+      expect(Shoryuken.workers['default']).to eq TestWorker
     end
 
     it 'accepts a block as queue name' do
       $queue_prefix = 'production'
 
-      class UppercutWorker
+      class NewTestWorker
         include Shoryuken::Worker
 
-        shoryuken_options queue: ->{ "#{$queue_prefix}_uppercut" }
+        shoryuken_options queue: ->{ "#{$queue_prefix}_default" }
       end
 
-      expect(Shoryuken.workers['production_uppercut']).to eq UppercutWorker
+      expect(Shoryuken.workers['production_default']).to eq NewTestWorker
     end
   end
 end

data/spec/spec_helper.rb

@@ -2,8 +2,8 @@ require 'bundler/setup'
 Bundler.setup
 
 require 'pry-byebug'
-require 'shoryuken'
 require 'celluloid'
+require 'shoryuken'
 
 options_file = File.join(File.expand_path('../..', __FILE__), 'shoryuken.yml')
 
@@ -18,6 +18,14 @@ end
 Shoryuken.logger.level = Logger::UNKNOWN
 Celluloid.logger.level = Logger::UNKNOWN
 
+class TestWorker
+  include Shoryuken::Worker
+
+  shoryuken_options queue: 'default'
+
+  def perform(sqs_msg, body); end
+end
+
 RSpec.configure do |config|
   config.filter_run_excluding slow: true unless ENV['SPEC_ALL']
 
@@ -38,5 +46,8 @@ RSpec.configure do |config|
     Shoryuken.options[:timeout]     = 1
 
     Shoryuken.options[:aws] = {}
+
+    TestWorker.get_shoryuken_options.clear
+    TestWorker.get_shoryuken_options['queue'] = 'default'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shoryuken
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Pablo Cantero
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-21 00:00:00.000000000 Z
+date: 2014-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,20 +94,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: multi_json
-  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: Shoryuken is a super efficient AWS SQS thread based message processor
 email:
 - pablo@pablocantero.com
@@ -125,9 +111,9 @@ files:
 - Rakefile
 - bin/shoryuken
 - examples/all.rb
-- examples/shoryuken_worker.rb
-- examples/sidekiq_worker.rb
-- examples/uppercut_worker.rb
+- examples/default_worker.rb
+- examples/high_priority_worker.rb
+- examples/low_priority_worker.rb
 - lib/shoryuken.rb
 - lib/shoryuken/cli.rb
 - lib/shoryuken/client.rb
@@ -137,8 +123,8 @@ files:
 - lib/shoryuken/logging.rb
 - lib/shoryuken/manager.rb
 - lib/shoryuken/middleware/chain.rb
-- lib/shoryuken/middleware/server/delete.rb
-- lib/shoryuken/middleware/server/logging.rb
+- lib/shoryuken/middleware/server/auto_delete.rb
+- lib/shoryuken/middleware/server/timing.rb
 - lib/shoryuken/processor.rb
 - lib/shoryuken/util.rb
 - lib/shoryuken/version.rb
@@ -151,7 +137,8 @@ files:
 - spec/shoryuken/fetcher_spec.rb
 - spec/shoryuken/manager_spec.rb
 - spec/shoryuken/middleware/chain_spec.rb
-- spec/shoryuken/middleware/server/delete_spec.rb
+- spec/shoryuken/middleware/server/auto_delete_spec.rb
+- spec/shoryuken/middleware/server/timing_spec.rb
 - spec/shoryuken/processor_spec.rb
 - spec/shoryuken/util_spec.rb
 - spec/shoryuken/worker_spec.rb
@@ -187,7 +174,8 @@ test_files:
 - spec/shoryuken/fetcher_spec.rb
 - spec/shoryuken/manager_spec.rb
 - spec/shoryuken/middleware/chain_spec.rb
-- spec/shoryuken/middleware/server/delete_spec.rb
+- spec/shoryuken/middleware/server/auto_delete_spec.rb
+- spec/shoryuken/middleware/server/timing_spec.rb
 - spec/shoryuken/processor_spec.rb
 - spec/shoryuken/util_spec.rb
 - spec/shoryuken/worker_spec.rb

data/examples/shoryuken_worker.rb

@@ -1,11 +0,0 @@
-class ShoryukenWorker
-  include Shoryuken::Worker
-
-  shoryuken_options queue: 'shoryuken', delete: true
-
-  def perform(sqs_msg)
-    puts "Shoryuken: '#{sqs_msg.body}'"
-
-    sleep rand(0..1)
-  end
-end

data/examples/sidekiq_worker.rb

@@ -1,11 +0,0 @@
-class SidekiqWorker
-  include Shoryuken::Worker
-
-  shoryuken_options queue: 'sidekiq', delete: true
-
-  def perform(sqs_msg)
-    puts "Sidekiq: '#{sqs_msg.body}'"
-
-    sleep rand(0..1)
-  end
-end

data/examples/uppercut_worker.rb

@@ -1,11 +0,0 @@
-class UppercutWorker
-  include Shoryuken::Worker
-
-  shoryuken_options queue: 'uppercut', delete: true
-
-  def perform(sqs_msg)
-    puts "Uppercut: '#{sqs_msg.body}'"
-
-    sleep rand(0..1)
-  end
-end

data/lib/shoryuken/middleware/server/delete.rb

@@ -1,17 +0,0 @@
-module Shoryuken
-  module Middleware
-    module Server
-      class Delete
-        def call(worker, queue, sqs_msg)
-          yield
-
-          # auto_delete is deprecated
-          delete = worker.class.get_shoryuken_options['delete'] || worker.class.get_shoryuken_options['auto_delete']
-
-          Array(sqs_msg).each(&:delete) if delete
-        end
-      end
-    end
-  end
-end
-

data/spec/shoryuken/middleware/server/delete_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe Shoryuken::Middleware::Server::Delete do
-  let(:sqs_msg) { double 'SQS msg' }
-
-  before do
-    DeleteWorker.get_shoryuken_options['delete'] = true
-  end
-
-  class DeleteWorker
-    include Shoryuken::Worker
-
-    shoryuken_options queue: 'delete', delete: true
-
-    def perform; end
-  end
-
-  it 'deletes a message' do
-    expect(sqs_msg).to receive(:delete)
-
-    subject.call(DeleteWorker.new, 'delete', sqs_msg) {}
-  end
-
-  it 'deletes a batch' do
-    sqs_msg2 = double
-    sqs_msg3 = double
-
-    expect(sqs_msg).to receive(:delete)
-    expect(sqs_msg2).to receive(:delete)
-    expect(sqs_msg3).to receive(:delete)
-
-    subject.call(DeleteWorker.new, 'delete', [sqs_msg, sqs_msg2, sqs_msg3]) {}
-  end
-
-  it 'does not delete a message' do
-    DeleteWorker.get_shoryuken_options['delete'] = false
-
-    expect(sqs_msg).to_not receive(:delete)
-
-    subject.call(DeleteWorker.new, 'delete', sqs_msg) {}
-  end
-
-  context 'when exception' do
-    it 'does not delete a message' do
-      expect(sqs_msg).to_not receive(:delete)
-
-      expect {
-        subject.call(DeleteWorker.new, 'delete', sqs_msg) { raise }
-      }.to raise_error
-    end
-  end
-end