ElmerFudd 0.0.26 → 0.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd6ca4c19eec0cfe4f1c67893e228e34de2738ff
-  data.tar.gz: ea6138eb02264f866a9953d3e931245393d6dcdd
+  metadata.gz: e2843148a1580faa5bb73307c9284a57bfb2e764
+  data.tar.gz: 72a3ed699a197649d2b2d396af5bb9c59dae17d2
 SHA512:
-  metadata.gz: 218fc0908e3aeed38a67737fedccaad4282faf858a2883773ff86a793172d663756f0275957d5b392482016fd128d02f726d8171b507c5060cb52328cfc67b17
-  data.tar.gz: 0c71524cae5acb9e7e5995ab08863e50b50b05f1053f9124631d270f678ad9d819bc067f7f6763d0bad95fb52d0ed3616243c76e761354ede2ad30bfb2f511ba
+  metadata.gz: c4c6386d99be4549b7f48bc05dd734f8919cf11034cd836b657acf5a3df5cb7bc3f230bbdd8afd46d7b85e7b7d78b08177af8f210c5235973b9e3176c033ffae
+  data.tar.gz: 359f11e19af4c4be2925dd962fa7dde6d3244baedd0f7fec94d56a398db93110382a228b3d9fa5d96be3c71c0b75b69aaf76b056b4489bb4aaedb5150a4c0425

data/README.md

@@ -116,3 +116,8 @@ end
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+** Credits
+- [Artur Roszczyk](https://github.com/sevos)
+- [Andrzej Sliwa](https://github.com/andrzejsliwa)
+- [Andrey Parubets](https://github.com/parubets)

data/lib/ElmerFudd.rb

@@ -1,361 +1,27 @@
-require "ElmerFudd/version"
-require "bunny"
-require "thread"
+require 'ElmerFudd/version'
+require 'bunny'
+require 'thread'
+require 'json'
 
 module ElmerFudd
-  class Publisher
-    def initialize(connection, uuid_service: -> { rand.to_s })
-      @connection = connection
-      @uuid_service = uuid_service
-      @topic_x = {}
-    end
-
-    def notify(topic_exchange, routing_key, payload)
-      @topic_x[topic_exchange] ||= channel.topic(topic_exchange)
-      @topic_x[topic_exchange].publish payload.to_s, routing_key: routing_key
-      nil
-    end
-
-    def cast(queue_name, payload)
-      x.publish(payload.to_s, routing_key: queue_name)
-      nil
-    end
-
-    def call(queue_name, payload, timeout: 10)
-      mutex = Mutex.new
-      resource = ConditionVariable.new
-      correlation_id = @uuid_service.call
-      consumer_tag = @uuid_service.call
-      response = nil
-
-      Timeout.timeout(timeout) do
-        rpc_reply_queue.subscribe(manual_ack: false, block: false, consumer_tag: consumer_tag) do |delivery_info, properties, payload|
-          if properties[:correlation_id] == correlation_id
-            response = payload
-            mutex.synchronize { resource.signal }
-          end
-        end
-
-        x.publish(payload.to_s, routing_key: queue_name, reply_to: rpc_reply_queue.name,
-                  correlation_id: correlation_id)
-
-        mutex.synchronize { resource.wait(mutex) unless response }
-        response
-      end
-    ensure
-      reply_channel.consumers[consumer_tag].cancel
-    end
-
-    private
-
-    def connection
-      @connection.tap do |c|
-        c.start unless c.connected?
-      end
-    end
-
-    def x
-      @x ||= channel.default_exchange
-    end
-
-    def channel
-      @channel ||= connection.create_channel
-    end
-
-    def reply_channel
-      @reply_channel ||= connection.create_channel
-    end
-
-    def rpc_reply_queue
-      @rpc_reply_queue ||= reply_channel.queue("", exclusive: true)
-    end
-  end
-
-  class JsonPublisher < Publisher
-    def notify(topic_exchange, routing_key, payload)
-      super(topic_exchange, routing_key, payload.to_json)
-    end
-
-    def cast(queue_name, payload)
-      super(queue_name, payload.to_json)
-    end
-
-    def call(queue_name, payload, **kwargs)
-      JSON.parse(super(queue_name, payload.to_json, **kwargs))
-    end
-  end
-
-  class Worker
-    Message = Struct.new(:delivery_info, :properties, :payload, :route)
-    Env = Struct.new(:channel, :logger, :worker_class)
-    Route = Struct.new(:exchange_name, :routing_keys, :queue_name)
-
-    def self.handlers
-      @handlers ||= []
-    end
-
-    def self.Route(queue_name, exchange_and_routing_keys = {"" => queue_name})
-      exchange, routing_keys = exchange_and_routing_keys.first
-      Route.new(exchange, routing_keys, queue_name)
-    end
-
-    def self.default_filters(*filters)
-      @filters = filters
-    end
-
-    def self.handle_event(route, filters: [], handler: nil, &block)
-      handlers << TopicHandler.new(route, handler || block, (@filters + filters + [DiscardReturnValueFilter]).uniq)
-    end
-
-    def self.handle_cast(route, filters: [], handler: nil, &block)
-      handlers << DirectHandler.new(route, handler || block, (@filters + filters + [DiscardReturnValueFilter]).uniq)
-    end
-
-    def self.handle_call(route, filters: [], handler: nil, &block)
-      handlers << RpcHandler.new(route, handler || block, (@filters + filters).uniq)
-    end
-
-    # Helper allowing to use any method taking hash as a handler
-    # def example(text:, **_)
-    #  puts text
-    # end
-    # # then in worker
-    # handle_cast(...
-    #             handler: payload_as_kwargs(method(:example)))
-    # Thanks to usage of **_ in arguments list it will accept
-    # any payload contaning 'text' key. Skipping **_ will require
-    # listing all payload keys in argument list
-    def self.payload_as_kwargs(handler, only: nil)
-      lambda do |_env, message|
-        symbolized_payload = message.payload.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
-        symbolized_payload = symbolized_payload.select { |k,v| Array(only).include?(k) } if only
-        handler.call(symbolized_payload)
-      end
-    end
-
-    def initialize(connection, concurrency: 1, logger: Logger.new($stdout))
-      @connection = connection
-      @concurrency = concurrency
-      @logger = logger
-    end
-
-    def start
-      self.class.handlers.each do |handler|
-        handler.queue(env).subscribe(manual_ack: true, block: false) do |delivery_info, properties, payload|
-          message = Message.new(delivery_info, properties, payload, handler.route)
-          begin
-            handler.call(env, message)
-            env.channel.acknowledge(message.delivery_info.delivery_tag)
-          rescue Exception => e
-            env.logger.fatal("Worker blocked: %s, %s:" % [e.class, e.message])
-            e.backtrace.each { |l| env.logger.fatal(l) }
-          end
-        end
-      end
-    end
-
-    private
-
-    def env
-      @env ||= Env.new(channel, @logger, self.class)
-    end
-
-    def connection
-      @connection.tap { |c| c.start unless c.connected? }
-    end
-
-    def channel
-      @channel ||= connection.create_channel.tap { |c| c.prefetch(@concurrency) }
-    end
-  end
-
-  module Filter
-    def call_next(env, message, filters)
-      next_filter, *remainder = filters
-      if remainder.empty?
-        next_filter.call(env, message)
-      else
-        next_filter.call(env, message, remainder)
-      end
-    end
-  end
-
-  class DirectHandler
-    include Filter
-    attr_reader :route
-
-    def initialize(route, callback, filters)
-      @route = route
-      @callback = callback
-      @filters = filters
-    end
-
-    def queue(env)
-      env.channel.queue(@route.queue_name, durable: true, exclusive: is_exclusive_queue).tap do |queue|
-        unless @route.exchange_name == ""
-          Array(@route.routing_keys).each do |routing_key|
-            queue.bind(exchange(env), routing_key: routing_key)
-          end
-        end
-      end
-    end
-
-    def exchange(env)
-      env.channel.direct(@route.exchange_name)
-    end
-
-    def call(env, message)
-      call_next(env, message, @filters + [@callback])
-    end
-
-    private
-
-    def is_exclusive_queue
-      @route.queue_name == ''
-    end
-  end
-
-  class TopicHandler < DirectHandler
-    def exchange(env)
-      env.channel.topic(@route.exchange_name, durable: false, internal: false, autodelete: false)
-    end
-  end
-
-  class RpcHandler < DirectHandler
-    def call(env, message)
-      reply(env, message, super)
-    end
-
-    def reply(env, original_message, response)
-      exchange(env).publish(response.to_s, routing_key: original_message.properties.reply_to,
-                            correlation_id: original_message.properties.correlation_id)
-    end
-  end
-
-  class JsonFilter
-    extend Filter
-    def self.call(env, message, filters)
-      message.payload = JSON.parse(message.payload)
-      {result: call_next(env, message, filters)}.to_json
-    rescue JSON::ParserError
-      env.logger.error "Ignoring invalid JSON: #{message.payload}"
-    end
-  end
-
-  class DropFailedFilter
-    include Filter
-
-    def self.call(env, message, filters)
-      new.call(env, message, filters)
-    end
-
-    def initialize(exception: Exception,
-                   exception_message_matches: /.*/)
-      @exception = exception
-      @exception_message_matches = exception_message_matches
-    end
-
-    def call(env, message, filters)
-      call_next(env, message, filters)
-    rescue @exception => e
-      if e.message =~ @exception_message_matches
-        env.logger.info "Ignoring failed payload: #{message.payload}"
-        env.logger.debug "#{e.class}: #{e.message}"
-        e.backtrace.each { |l| env.logger.debug(l) }
-      else
-        raise
-      end
-    end
-  end
-
-  class AirbrakeFilter
-    extend Filter
-    def self.call(env, message, filters)
-      call_next(env, message, filters)
-    rescue Exception => e
-      Airbrake.notify(e, parameters: {
-                        payload: message.payload,
-                        queue: message.route.queue_name,
-                        exchange_name: message.route.exchange_name,
-                        routing_key: message.delivery_info.routing_key,
-                        matched_routing_key: message.route.routing_keys
-                      })
-      raise
-    end
-  end
-
-  class ActiveRecordConnectionPoolFilter
-    extend Filter
-    def self.call(env, message, filters)
-      retry_num = 0
-      begin
-        ActiveRecord::Base.connection_pool.with_connection do
-          call_next(env, message, filters)
-        end
-      rescue ActiveRecord::ConnectionTimeoutError
-        retry_num += 1
-        if retry_num <= 5
-          sleep 1
-          retry
-        else
-          raise
-        end
-      end
-    end
-  end
-
-  class DiscardReturnValueFilter
-    extend Filter
-    def self.call(env, message, filters)
-      call_next(env, message, filters)
-      nil
-    end
-  end
-
-  class RedirectFailedFilter
-    include Filter
-    def initialize(producer, error_queue, exception: Exception,
-                   exception_message_matches: /.*/)
-      @producer = producer
-      @error_queue = error_queue
-      @exception = exception
-      @exception_message_matches = exception_message_matches
-    end
-
-    def call(env, message, filters)
-      call_next(env, message, filters)
-    rescue @exception => e
-      if e.message =~ @exception_message_matches
-        @producer.cast @error_queue, message.payload
-      else
-        raise
-      end
-    end
-  end
-
-  class RetryFilter
-    include Filter
-
-    def initialize(times, exception: Exception,
-                   exception_message_matches: /.*/)
-      @times = times
-      @exception = exception
-      @exception_message_matches = exception_message_matches
-    end
-
-    def call(env, message, filters)
-      retry_num = 0
-      begin
-        call_next(env, message, filters)
-      rescue @exception => e
-        if e.message =~ @exception_message_matches && retry_num < @times
-          retry_num += 1
-          sleep Math.log(retry_num, 2)
-          retry
-        else
-          raise
-        end
-      end
-    end
-  end
+  require 'ElmerFudd/publisher'
+  require 'ElmerFudd/json_publisher'
+
+  require 'ElmerFudd/filter'
+  require 'ElmerFudd/direct_handler'
+  require 'ElmerFudd/topic_handler'
+  require 'ElmerFudd/rpc_handler'
+  if defined?(Rspec)
+    require 'ElmerFudd/rspec'
+  end
+  require 'ElmerFudd/worker'
+
+
+  require 'ElmerFudd/active_record_connection_pool_filter'
+  require 'ElmerFudd/airbrake_filter'
+  require 'ElmerFudd/discard_return_value_filter'
+  require 'ElmerFudd/drop_failed_filter'
+  require 'ElmerFudd/json_filter'
+  require 'ElmerFudd/redirect_failed_filter'
+  require 'ElmerFudd/retry_filter'
 end

data/lib/ElmerFudd/active_record_connection_pool_filter.rb

@@ -0,0 +1,21 @@
+module ElmerFudd
+  class ActiveRecordConnectionPoolFilter
+    extend Filter
+    def self.call(env, message, filters)
+      retry_num = 0
+      begin
+        ActiveRecord::Base.connection_pool.with_connection do
+          call_next(env, message, filters)
+        end
+      rescue ActiveRecord::ConnectionTimeoutError
+        retry_num += 1
+        if retry_num <= 5
+          sleep 1
+          retry
+        else
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/ElmerFudd/airbrake_filter.rb

@@ -0,0 +1,17 @@
+module ElmerFudd
+  class AirbrakeFilter
+    extend Filter
+    def self.call(env, message, filters)
+      call_next(env, message, filters)
+    rescue Exception => e
+      Airbrake.notify(e, parameters: {
+                        payload: message.payload,
+                        queue: message.route.queue_name,
+                        exchange_name: message.route.exchange_name,
+                        routing_key: message.delivery_info.routing_key,
+                        matched_routing_key: message.route.routing_keys
+                      })
+      raise
+    end
+  end
+end

data/lib/ElmerFudd/direct_handler.rb

@@ -0,0 +1,42 @@
+module ElmerFudd
+  class DirectHandler
+    include Filter
+    attr_reader :route
+
+    def initialize(route, callback, filters)
+      @route = route
+      @callback = callback
+      @filters = filters
+    end
+
+    def queue(env)
+      env.channel.queue(@route.queue_name, durable: true, exclusive: is_exclusive_queue).tap do |queue|
+        unless @route.exchange_name == ""
+          Array(@route.routing_keys).each do |routing_key|
+            queue.bind(exchange(env), routing_key: routing_key)
+          end
+        end
+      end
+    end
+
+    def exchange(env)
+      env.logger.debug "ElmerFudd Handler.exchange queue_name: #{@route.queue_name}, exchange_name: #{@route.exchange_name}, filters: #{filters_names}"
+      env.channel.direct(@route.exchange_name)
+    end
+
+    def call(env, message)
+      env.logger.debug "ElmerFudd DirectHandler.call queue_name: #{@route.queue_name}, exchange_name: #{@route.exchange_name}, filters: #{filters_names}, message: #{message.payload}"
+      call_next(env, message, @filters + [@callback])
+    end
+
+    private
+
+    def filters_names
+      @filters.map { |f| f.respond_to?(:name) ? f.name : f.class.name }
+    end
+
+    def is_exclusive_queue
+      @route.queue_name == ''
+    end
+  end
+end

data/lib/ElmerFudd/discard_return_value_filter.rb

@@ -0,0 +1,9 @@
+module ElmerFudd
+  class DiscardReturnValueFilter
+    extend Filter
+    def self.call(env, message, filters)
+      call_next(env, message, filters)
+      nil
+    end
+  end
+end

data/lib/ElmerFudd/drop_failed_filter.rb

@@ -0,0 +1,27 @@
+module ElmerFudd
+  class DropFailedFilter
+    include Filter
+
+    def self.call(env, message, filters)
+      new.call(env, message, filters)
+    end
+
+    def initialize(exception: Exception,
+                   exception_message_matches: /.*/)
+      @exception = exception
+      @exception_message_matches = exception_message_matches
+    end
+
+    def call(env, message, filters)
+      call_next(env, message, filters)
+    rescue @exception => e
+      if e.message =~ @exception_message_matches
+        env.logger.info "Ignoring failed payload: #{message.payload}"
+        env.logger.debug "#{e.class}: #{e.message}"
+        e.backtrace.each { |l| env.logger.debug(l) }
+      else
+        raise
+      end
+    end
+  end
+end

data/lib/ElmerFudd/filter.rb

@@ -0,0 +1,12 @@
+module ElmerFudd
+  module Filter
+    def call_next(env, message, filters)
+      next_filter, *remainder = filters
+      if remainder.empty?
+        next_filter.call(env, message)
+      else
+        next_filter.call(env, message, remainder)
+      end
+    end
+  end
+end

data/lib/ElmerFudd/json_filter.rb

@@ -0,0 +1,11 @@
+module ElmerFudd
+  class JsonFilter
+    extend Filter
+    def self.call(env, message, filters)
+      message.payload = JSON.parse(message.payload)
+      {result: call_next(env, message, filters)}.to_json
+    rescue JSON::ParserError
+      env.logger.error "Ignoring invalid JSON: #{message.payload}"
+    end
+  end
+end

data/lib/ElmerFudd/json_publisher.rb

@@ -0,0 +1,15 @@
+module ElmerFudd
+  class JsonPublisher < Publisher
+    def notify(topic_exchange, routing_key, payload)
+      super(topic_exchange, routing_key, payload.to_json)
+    end
+
+    def cast(queue_name, payload)
+      super(queue_name, payload.to_json)
+    end
+
+    def call(queue_name, payload, **kwargs)
+      JSON.parse(super(queue_name, payload.to_json, **kwargs))
+    end
+  end
+end

data/lib/ElmerFudd/publisher.rb

@@ -0,0 +1,74 @@
+module ElmerFudd
+  class Publisher
+    def initialize(connection, uuid_service: -> { rand.to_s }, logger: Logger.new($stdout))
+      puts "LOGGGER #{logger}"
+      @connection = connection
+      @logger = logger
+      @uuid_service = uuid_service
+      @topic_x = {}
+    end
+
+    def notify(topic_exchange, routing_key, payload)
+      @logger.debug "ElmerFudd: NOTIFY - topic_exchange: #{topic_exchange}, routing_key: #{routing_key}, payload: #{payload}"
+      @topic_x[topic_exchange] ||= channel.topic(topic_exchange)
+      @topic_x[topic_exchange].publish payload.to_s, routing_key: routing_key
+      nil
+    end
+
+    def cast(queue_name, payload)
+      @logger.debug "ElmerFudd: CAST - queue_name: #{queue_name}, payload: #{payload}"
+      x.publish(payload.to_s, routing_key: queue_name)
+      nil
+    end
+
+    def call(queue_name, payload, timeout: 10)
+      @logger.debug "ElmerFudd: CALL - queue_name: #{queue_name}, payload: #{payload}, timeout: #{timeout}"
+      mutex = Mutex.new
+      resource = ConditionVariable.new
+      correlation_id = @uuid_service.call
+      consumer_tag = @uuid_service.call
+      response = nil
+
+      Timeout.timeout(timeout) do
+        rpc_reply_queue.subscribe(manual_ack: false, block: false, consumer_tag: consumer_tag) do |delivery_info, properties, payload|
+          if properties[:correlation_id] == correlation_id
+            response = payload
+            mutex.synchronize { resource.signal }
+          end
+        end
+
+        x.publish(payload.to_s, routing_key: queue_name, reply_to: rpc_reply_queue.name,
+                  correlation_id: correlation_id)
+
+        mutex.synchronize { resource.wait(mutex) unless response }
+        response
+      end
+    ensure
+      reply_channel.consumers[consumer_tag].cancel
+    end
+
+    private
+
+    def connection
+      @connection.tap do |c|
+        c.start unless c.connected?
+      end
+    end
+
+    def x
+      @x ||= channel.default_exchange
+    end
+
+    def channel
+      @channel ||= connection.create_channel
+    end
+
+    def reply_channel
+      @reply_channel ||= connection.create_channel
+    end
+
+    def rpc_reply_queue
+      @rpc_reply_queue ||= reply_channel.queue("", exclusive: true)
+    end
+  end
+end

data/lib/ElmerFudd/redirect_failed_filter.rb

@@ -0,0 +1,22 @@
+module ElmerFudd
+  class RedirectFailedFilter
+    include Filter
+    def initialize(producer, error_queue, exception: Exception,
+                   exception_message_matches: /.*/)
+      @producer = producer
+      @error_queue = error_queue
+      @exception = exception
+      @exception_message_matches = exception_message_matches
+    end
+
+    def call(env, message, filters)
+      call_next(env, message, filters)
+    rescue @exception => e
+      if e.message =~ @exception_message_matches
+        @producer.cast @error_queue, message.payload
+      else
+        raise
+      end
+    end
+  end
+end

data/lib/ElmerFudd/retry_filter.rb

@@ -0,0 +1,27 @@
+module ElmerFudd
+  class RetryFilter
+    include Filter
+
+    def initialize(times, exception: Exception,
+                   exception_message_matches: /.*/)
+      @times = times
+      @exception = exception
+      @exception_message_matches = exception_message_matches
+    end
+
+    def call(env, message, filters)
+      retry_num = 0
+      begin
+        call_next(env, message, filters)
+      rescue @exception => e
+        if e.message =~ @exception_message_matches && retry_num < @times
+          retry_num += 1
+          sleep Math.log(retry_num, 2)
+          retry
+        else
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/ElmerFudd/rpc_handler.rb

@@ -0,0 +1,14 @@
+module ElmerFudd
+  class RpcHandler < DirectHandler
+    def call(env, message)
+      env.logger.debug "ElmerFudd RpcHandler.call queue_name: #{@route.queue_name}, exchange_name: #{@route.exchange_name}, filters: #{@filters.map(&:name)}, message: #{message.payload}"
+
+      reply(env, message, super)
+    end
+
+    def reply(env, original_message, response)
+      exchange(env).publish(response.to_s, routing_key: original_message.properties.reply_to,
+                            correlation_id: original_message.properties.correlation_id)
+    end
+  end
+end

data/lib/ElmerFudd/topic_handler.rb

@@ -0,0 +1,8 @@
+module ElmerFudd
+  class TopicHandler < DirectHandler
+    def exchange(env)
+      env.logger.debug "ElmerFudd TopicHandler.exchange queue_name: #{@route.queue_name}, exchange_name: #{@route.exchange_name}, filters: #{filters_names}"
+      env.channel.topic(@route.exchange_name, durable: false, internal: false, autodelete: false)
+    end
+  end
+end

data/lib/ElmerFudd/version.rb

@@ -1,3 +1,3 @@
 module ElmerFudd
-  VERSION = "0.0.26"
+  VERSION = "0.0.27"
 end

data/lib/ElmerFudd/worker.rb

@@ -0,0 +1,85 @@
+module ElmerFudd
+  class Worker
+    Message = Struct.new(:delivery_info, :properties, :payload, :route)
+    Env = Struct.new(:channel, :logger, :worker_class)
+    Route = Struct.new(:exchange_name, :routing_keys, :queue_name)
+
+    def self.handlers
+      @handlers ||= []
+    end
+
+    def self.Route(queue_name, exchange_and_routing_keys = {"" => queue_name})
+      exchange, routing_keys = exchange_and_routing_keys.first
+      Route.new(exchange, routing_keys, queue_name)
+    end
+
+    def self.default_filters(*filters)
+      @filters = filters
+    end
+
+    def self.handle_event(route, filters: [], handler: nil, &block)
+      handlers << TopicHandler.new(route, handler || block, (@filters + filters + [DiscardReturnValueFilter]).uniq)
+    end
+
+    def self.handle_cast(route, filters: [], handler: nil, &block)
+      handlers << DirectHandler.new(route, handler || block, (@filters + filters + [DiscardReturnValueFilter]).uniq)
+    end
+
+    def self.handle_call(route, filters: [], handler: nil, &block)
+      handlers << RpcHandler.new(route, handler || block, (@filters + filters).uniq)
+    end
+
+    # Helper allowing to use any method taking hash as a handler
+    # def example(text:, **_)
+    #  puts text
+    # end
+    # # then in worker
+    # handle_cast(...
+    #             handler: payload_as_kwargs(method(:example)))
+    # Thanks to usage of **_ in arguments list it will accept
+    # any payload contaning 'text' key. Skipping **_ will require
+    # listing all payload keys in argument list
+    def self.payload_as_kwargs(handler, only: nil)
+      lambda do |_env, message|
+        symbolized_payload = message.payload.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+        sybolized_payload = symbolized_payload.select { |k,v| Array(only).include?(k) } if only
+        handler.call(symbolized_payload)
+      end
+    end
+
+    def initialize(connection, concurrency: 1, logger: Logger.new($stdout))
+      @connection = connection
+      @concurrency = concurrency
+      @logger = logger
+    end
+
+    def start
+      self.class.handlers.each do |handler|
+        handler.queue(env).subscribe(manual_ack: true, block: false) do |delivery_info, properties, payload|
+          message = Message.new(delivery_info, properties, payload, handler.route)
+          begin
+            handler.call(env, message)
+            env.channel.acknowledge(message.delivery_info.delivery_tag)
+          rescue Exception => e
+            env.logger.fatal("Worker blocked: %s, %s:" % [e.class, e.message])
+            e.backtrace.each { |l| env.logger.fatal(l) }
+          end
+        end
+      end
+    end
+
+    private
+
+    def env
+      @env ||= Env.new(channel, @logger, self.class)
+    end
+
+    def connection
+      @connection.tap { |c| c.start unless c.connected? }
+    end
+
+    def channel
+      @channel ||= connection.create_channel.tap { |c| c.prefetch(@concurrency) }
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ElmerFudd
 version: !ruby/object:Gem::Version
-  version: 0.0.26
+  version: 0.0.27
 platform: ruby
 authors:
 - Andrzej Sliwa
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-15 00:00:00.000000000 Z
+date: 2015-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -86,8 +86,22 @@ files:
 - Rakefile
 - elmer-fudd.jpg
 - lib/ElmerFudd.rb
+- lib/ElmerFudd/active_record_connection_pool_filter.rb
+- lib/ElmerFudd/airbrake_filter.rb
+- lib/ElmerFudd/direct_handler.rb
+- lib/ElmerFudd/discard_return_value_filter.rb
+- lib/ElmerFudd/drop_failed_filter.rb
+- lib/ElmerFudd/filter.rb
+- lib/ElmerFudd/json_filter.rb
+- lib/ElmerFudd/json_publisher.rb
+- lib/ElmerFudd/publisher.rb
+- lib/ElmerFudd/redirect_failed_filter.rb
+- lib/ElmerFudd/retry_filter.rb
+- lib/ElmerFudd/rpc_handler.rb
 - lib/ElmerFudd/rspec.rb
+- lib/ElmerFudd/topic_handler.rb
 - lib/ElmerFudd/version.rb
+- lib/ElmerFudd/worker.rb
 - spec/spec_helper.rb
 homepage: https://github.com/bonusboxme/ElmerFudd
 licenses:
@@ -109,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: RabbitMQ in OTP way