hutch 0.25.0.pre.rc1-java → 2.0.0.rc1-java

data/lib/hutch/error_handlers/honeybadger.rb

@@ -1,11 +1,11 @@
 require 'hutch/logging'
 require 'honeybadger'
+require 'hutch/error_handlers/base'
 
 module Hutch
   module ErrorHandlers
     # Error handler for the Honeybadger.io service
-    class Honeybadger
-      include Logging
+    class Honeybadger < Base
 
       def handle(properties, payload, consumer, ex)
         message_id = properties.message_id
@@ -20,6 +20,14 @@ module Hutch
                            parameters: { payload: payload })
       end
 
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Honeybadger"
+        logger.error "#{ex.class} - #{ex.message}"
+        notify_honeybadger(error_class: ex.class.name,
+                           error_message: "#{ex.class.name}: #{ex.message}",
+                           backtrace: ex.backtrace)
+      end
+
       # Wrap API to support 3.0.0+
       #
       # @see https://github.com/honeybadger-io/honeybadger-ruby/blob/master/CHANGELOG.md#300---2017-02-06
@@ -27,7 +35,7 @@ module Hutch
         if ::Honeybadger.respond_to?(:notify_or_ignore)
           ::Honeybadger.notify_or_ignore(message)
         else
-          ::Honeybadger.notify(message.merge(force: true))
+          ::Honeybadger.notify(message)
         end
       end
     end

data/lib/hutch/error_handlers/logger.rb

@@ -1,9 +1,9 @@
 require 'hutch/logging'
+require 'hutch/error_handlers/base'
 
 module Hutch
   module ErrorHandlers
-    class Logger
-      include Logging
+    class Logger < ErrorHandlers::Base
 
       def handle(properties, payload, consumer, ex)
         message_id = properties.message_id
@@ -12,6 +12,11 @@ module Hutch
         logger.error "#{prefix} #{ex.class} - #{ex.message}"
         logger.error (['backtrace:'] + ex.backtrace).join("\n")
       end
+
+      def handle_setup_exception(ex)
+        logger.error "#{ex.class} - #{ex.message}"
+        logger.error (['backtrace:'] + ex.backtrace).join("\n")
+      end
     end
   end
 end

data/lib/hutch/error_handlers/rollbar.rb

@@ -0,0 +1,28 @@
+require 'hutch/logging'
+require 'rollbar'
+require 'hutch/error_handlers/base'
+
+module Hutch
+  module ErrorHandlers
+    class Rollbar < Base
+      def handle(properties, payload, consumer, ex)
+        message_id = properties.message_id
+        prefix = "message(#{message_id || '-'}):"
+        logger.error "#{prefix} Logging event to Rollbar"
+        logger.error "#{prefix} #{ex.class} - #{ex.message}"
+
+        ::Rollbar.error(ex,
+          payload: payload,
+          consumer: consumer
+        )
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Rollbar"
+        logger.error "#{ex.class} - #{ex.message}"
+
+        ::Rollbar.error(ex)
+      end
+    end
+  end
+end

data/lib/hutch/error_handlers/sentry.rb

@@ -1,23 +1,25 @@
 require 'hutch/logging'
-require 'raven'
+require 'sentry-ruby'
+require 'hutch/error_handlers/base'
 
 module Hutch
   module ErrorHandlers
-    class Sentry
-      include Logging
-
-      def initialize
-        unless Raven.respond_to?(:capture_exception)
-          raise "The Hutch Sentry error handler requires Raven >= 0.4.0"
-        end
-      end
-
+    class Sentry < Base
       def handle(properties, payload, consumer, ex)
         message_id = properties.message_id
         prefix = "message(#{message_id || '-'}):"
         logger.error "#{prefix} Logging event to Sentry"
         logger.error "#{prefix} #{ex.class} - #{ex.message}"
-        Raven.capture_exception(ex, extra: { payload: payload })
+        ::Sentry.configure_scope do |scope|
+          scope.set_context("payload", JSON.parse(payload))
+        end
+        ::Sentry.capture_exception(ex)
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Sentry"
+        logger.error "#{ex.class} - #{ex.message}"
+        ::Sentry.capture_exception(ex)
       end
     end
   end

data/lib/hutch/error_handlers.rb

@@ -4,6 +4,7 @@ module Hutch
     autoload :Sentry,      'hutch/error_handlers/sentry'
     autoload :Honeybadger, 'hutch/error_handlers/honeybadger'
     autoload :Airbrake,    'hutch/error_handlers/airbrake'
-    autoload :Opbeat,      'hutch/error_handlers/opbeat'
+    autoload :Rollbar,     'hutch/error_handlers/rollbar'
+    autoload :Bugsnag,     'hutch/error_handlers/bugsnag'
   end
 end

data/lib/hutch/publisher.rb

@@ -42,7 +42,7 @@ module Hutch
     private
 
     def log_publication(serializer, payload, routing_key)
-      logger.info {
+      logger.debug {
         spec =
           if serializer.binary?
             "#{payload.bytesize} bytes message"

data/lib/hutch/serializers/json.rb

@@ -1,4 +1,4 @@
-require 'multi_json'
+require 'json'
 require 'active_support/core_ext/hash/indifferent_access'
 
 module Hutch
@@ -6,11 +6,11 @@ module Hutch
     class JSON
 
       def self.encode(payload)
-        ::JSON.dump(payload)
+        ::JSON.generate(payload)
       end
 
       def self.decode(payload)
-        ::MultiJson.load(payload).with_indifferent_access
+        ::JSON.parse(payload).with_indifferent_access
       end
 
       def self.binary? ; false ; end

data/lib/hutch/tracers/datadog.rb

@@ -0,0 +1,18 @@
+require 'datadog'
+require 'datadog/auto_instrument'
+
+module Hutch
+  module Tracers
+    class Datadog
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def handle(message)
+        ::Datadog::Tracing.trace(@klass.class.name, continue_from: nil, service: 'hutch', type: 'rabbitmq') do
+          @klass.process(message)
+        end
+      end
+    end
+  end
+end

data/lib/hutch/tracers.rb

@@ -2,6 +2,6 @@ module Hutch
   module Tracers
     autoload :NullTracer, 'hutch/tracers/null_tracer'
     autoload :NewRelic,   'hutch/tracers/newrelic'
-    autoload :Opbeat,     'hutch/tracers/opbeat'
+    autoload :Datadog,    'hutch/tracers/datadog'
   end
 end

data/lib/hutch/version.rb

@@ -1,4 +1,3 @@
 module Hutch
-  VERSION = '0.25.0-rc1'.freeze
+  VERSION = '2.0.0.rc1'.freeze
 end
-

data/lib/hutch/waiter.rb

@@ -50,7 +50,7 @@ module Hutch
       end
     end
 
-    # @raises ContinueProcessingSignals
+    # @raise ContinueProcessingSignals
     def handle_user_signal(sig)
       case sig
       when 'USR2' then log_thread_backtraces

data/lib/hutch/worker.rb

@@ -11,8 +11,9 @@ module Hutch
     include Logging
 
     def initialize(broker, consumers, setup_procs)
-      @broker        = broker
-      self.consumers = consumers
+      @broker         = broker
+      @recovery_lock  = Mutex.new
+      self.consumers  = consumers
       self.setup_procs = setup_procs
     end
 
@@ -36,21 +37,62 @@ module Hutch
     # Set up the queues for each of the worker's consumers.
     def setup_queues
       logger.info 'setting up queues'
-      @consumers.each { |consumer| setup_queue(consumer) }
+      vetted = @consumers.reject { |c| group_configured? && group_restricted?(c) }
+      vetted.each do |c|
+        setup_queue(c)
+      end
     end
 
     # Bind a consumer's routing keys to its queue, and set up a subscription to
     # receive messages sent to the queue.
     def setup_queue(consumer)
-      queue = @broker.queue(consumer.get_queue_name, consumer.get_arguments)
+      queue_name = consumer.get_queue_name
+      queue_name = @broker.namespaced_queue_name(queue_name) unless consumer.without_namespace?
+      logger.info "setting up queue: #{queue_name}"
+
+      queue = @broker.queue(queue_name, consumer.get_options)
       @broker.bind_queue(queue, consumer.routing_keys)
 
-      queue.subscribe(consumer_tag: unique_consumer_tag, manual_ack: true) do |*args|
+      on_cancellation = proc { handle_cancellation(queue_name, queue.channel) }
+      queue.subscribe(consumer_tag: unique_consumer_tag, manual_ack: true,
+                      on_cancellation: on_cancellation) do |*args|
         delivery_info, properties, payload = Hutch::Adapter.decode_message(*args)
         handle_message(consumer, delivery_info, properties, payload)
       end
     end
 
+    # A server-sent `basic.cancel` carries no reason, so a consumer timeout
+    # is indistinguishable from a queue deletion. Only the former is recoverable.
+    def handle_cancellation(queue_name, cancelled_channel)
+      unless @broker.queue_exists?(queue_name)
+        logger.error "consumer on queue #{queue_name} was cancelled by the server: the queue no longer exists"
+        return
+      end
+
+      logger.warn "consumer on queue #{queue_name} was cancelled by the server, re-subscribing"
+      resubscribe_on_a_new_channel(cancelled_channel)
+    rescue => ex
+      logger.error "consumer re-subscription failed: #{ex.class}: #{ex.message}"
+    end
+
+    # Runs on its own thread: closing the channel kills the consumer work
+    # pool this callback runs on. Returns the thread so that tests can join it.
+    def resubscribe_on_a_new_channel(cancelled_channel)
+      Thread.new do
+        begin
+          @recovery_lock.synchronize do
+            # All consumers share the channel, so only the first cancellation replaces it.
+            next unless @broker.channel.equal?(cancelled_channel)
+
+            @broker.replace_channel!
+            setup_queues
+          end
+        rescue => ex
+          logger.error "consumer re-subscription failed: #{ex.class}: #{ex.message}"
+        end
+      end
+    end
+
     # Called internally when a new messages comes in from RabbitMQ. Responsible
     # for wrapping up the message and passing it to the consumer.
     def handle_message(consumer, delivery_info, properties, payload)
@@ -66,10 +108,10 @@ module Hutch
       message = Message.new(delivery_info, properties, payload, serializer)
       consumer_instance = consumer.new.tap { |c| c.broker, c.delivery_info = @broker, delivery_info }
       with_tracing(consumer_instance).handle(message)
-      @broker.ack(delivery_info.delivery_tag)
+      @broker.ack(delivery_info.delivery_tag, channel: delivery_info.channel) unless consumer_instance.message_rejected?
     rescue => ex
       acknowledge_error(delivery_info, properties, @broker, ex)
-      handle_error(properties, payload, consumer, ex)
+      handle_error(properties, payload, consumer, ex, delivery_info)
     end
 
     def with_tracing(klass)
@@ -78,7 +120,7 @@ module Hutch
 
     def handle_error(*args)
       Hutch::Config[:error_handlers].each do |backend|
-        backend.handle(*args)
+        backend.handle *args.first(backend.method(:handle).arity)
       end
     end
 
@@ -103,6 +145,30 @@ module Hutch
 
     private
 
+    def group_configured?
+      if group.present? && consumer_groups.blank?
+        logger.info 'Consumer groups are blank'
+      end
+      group.present?
+    end
+
+    def group_restricted?(consumer)
+      consumers_to_load = consumer_groups[group]
+      if consumers_to_load
+        !consumers_to_load.include?(consumer.name)
+      else
+        true
+      end
+    end
+
+    def group
+      Hutch::Config[:group]
+    end
+
+    def consumer_groups
+      Hutch::Config[:consumer_groups]
+    end
+
     attr_accessor :setup_procs
 
     def unique_consumer_tag

data/lib/hutch.rb

@@ -14,6 +14,8 @@ require 'hutch/exceptions'
 require 'hutch/tracers'
 
 module Hutch
+  @@connection_mutex = Mutex.new
+
   def self.register_consumer(consumer)
     self.consumers << consumer
   end
@@ -40,10 +42,12 @@ module Hutch
   # @param config [Hash] Configuration
   # @option options [Boolean] :enable_http_api_use
   def self.connect(options = {}, config = Hutch::Config)
-    return if connected?
-
-    @broker = Hutch::Broker.new(config)
-    @broker.connect(options)
+    @@connection_mutex.synchronize do
+      unless connected?
+        @broker = Hutch::Broker.new(config)
+        @broker.connect(options)
+      end
+    end
   end
 
   def self.disconnect

data/lib/yard-settings/yard-settings.rb

@@ -1,2 +1,2 @@
-YARD::Templates::Engine.register_template_path(File.dirname(__FILE__) + '/../../templates')
-require File.join(File.dirname(__FILE__), 'handler') if RUBY19
+YARD::Templates::Engine.register_template_path(File.join(__dir__, '../../templates'))
+require_relative 'handler'

data/spec/hutch/broker_spec.rb

@@ -92,6 +92,110 @@ describe Hutch::Broker do
 
       connection.close
     end
+
+    context 'when configured with a URI' do
+      context 'which specifies the port' do
+        before { config[:uri] = "amqp://#{config[:mq_username]}:#{config[:mq_password]}@#{config[:mq_host]}:#{config[:mq_port]}/" }
+
+        it 'successfully connects' do
+          c = broker.open_connection
+          expect(c).to be_open
+          c.close
+        end
+      end
+
+      context 'which does not specify port and uses the amqp scheme' do
+        before { config[:uri] = "amqp://#{config[:mq_username]}:#{config[:mq_password]}@#{config[:mq_host]}/" }
+
+        it 'successfully connects' do
+          c = broker.open_connection
+          expect(c).to be_open
+          c.close
+        end
+      end
+
+      context 'which specifies the amqps scheme' do
+        before { config[:uri] = "amqps://#{config[:mq_username]}:#{config[:mq_password]}@#{config[:mq_host]}/" }
+
+        it 'utilises TLS' do
+          expect(Hutch::Adapter).to receive(:new).with(
+            hash_including(tls: true)
+          ).and_return(instance_double('Hutch::Adapter', start: nil))
+
+          broker.open_connection
+        end
+      end
+    end
+  end
+
+  describe '#parse_uri' do
+    {
+      "amqp://host/vhost"    => "vhost",
+      "amqp://host/v%2fhost" => "v/host",
+      "amqp://host/%2f"      => "/",
+      "amqp://host/"         => Hutch::Adapter::DEFAULT_VHOST,
+      "amqp://host"          => Hutch::Adapter::DEFAULT_VHOST,
+    }.each do |uri, vhost|
+      it "parses the vhost of #{uri} as #{vhost.inspect}" do
+        config[:uri] = uri
+        broker.send(:parse_uri)
+
+        expect(config[:mq_vhost]).to eq(vhost)
+      end
+    end
+
+    it 'passes the vhost to the connection unchanged' do
+      config[:uri] = "amqp://host/%2f"
+
+      expect(broker.send(:connection_params)[:vhost]).to eq("/")
+    end
+
+    it 'percent-decodes the username and password' do
+      config[:uri] = "amqp://al%23pha:be%20ta@host:10000/vhost"
+      broker.send(:parse_uri)
+
+      expect(config[:mq_username]).to eq("al#pha")
+      expect(config[:mq_password]).to eq("be ta")
+    end
+
+    it 'leaves absent credentials nil' do
+      config[:uri] = "amqp://host:10000/vhost"
+      broker.send(:parse_uri)
+
+      expect(config[:mq_username]).to be_nil
+      expect(config[:mq_password]).to be_nil
+    end
+  end
+
+  describe '#bindings', 'vhost filtering' do
+    let(:api_bindings) do
+      [{ 'source' => 'hutch', 'vhost' => '/', 'destination' => 'q', 'routing_key' => 'key' }]
+    end
+
+    before do
+      config[:mq_exchange] = 'hutch'
+      broker.api_client = double('api_client', bindings: api_bindings)
+    end
+
+    it 'filters on the default vhost when the configured vhost is blank' do
+      config[:mq_vhost] = ''
+
+      expect(broker.bindings).to eq('q' => ['key'])
+    end
+  end
+
+  describe '#sanitized_uri' do
+    it 'percent-encodes the decoded username and vhost again' do
+      config[:uri] = 'amqp://al%23pha:be%20ta@host:10000/v%2Fhost'
+
+      expect(broker.send(:sanitized_uri)).to eq('amqp://al%23pha@host:10000/v%2Fhost')
+    end
+
+    it 'renders the default vhost as a bare trailing slash' do
+      config[:uri] = 'amqp://alpha:beta@host:10000/'
+
+      expect(broker.send(:sanitized_uri)).to eq('amqp://alpha@host:10000/')
+    end
   end
 
   describe '#open_connection!' do
@@ -165,6 +269,100 @@ describe Hutch::Broker do
     end
   end
 
+  describe '#replace_channel!', adapter: :bunny do
+    let(:old_channel) { double('Bunny::Channel', open?: true, close: nil) }
+    let(:new_channel) { double('Bunny::Channel').as_null_object }
+    let(:work_pool) { double('Bunny::ConsumerWorkPool', shutdown: nil, join: nil, kill: nil) }
+
+    before do
+      broker.channel = old_channel
+      allow(broker).to receive(:channel_work_pool).and_return(work_pool)
+      allow(broker).to receive(:open_channel).and_return(new_channel)
+      allow(broker).to receive(:declare_exchange!)
+      allow(broker).to receive(:declare_publisher!)
+    end
+
+    it 'drains the work pool before closing the old channel' do
+      expect(work_pool).to receive(:shutdown).ordered
+      expect(work_pool).to receive(:join).with(config[:graceful_exit_timeout]).ordered
+      expect(work_pool).to receive(:kill).ordered
+      expect(old_channel).to receive(:close).ordered
+
+      broker.replace_channel!
+    end
+
+    it 'redeclares the exchange and the publisher on the new channel' do
+      expect(broker).to receive(:declare_exchange!)
+      expect(broker).to receive(:declare_publisher!)
+
+      broker.replace_channel!
+
+      expect(broker.channel).to eq(new_channel)
+    end
+
+    context 'when the old channel is already closed' do
+      let(:old_channel) { double('Bunny::Channel', open?: false) }
+
+      it 'opens a new channel anyway' do
+        expect(old_channel).not_to receive(:close)
+        expect(work_pool).not_to receive(:shutdown)
+
+        broker.replace_channel!
+
+        expect(broker.channel).to eq(new_channel)
+      end
+    end
+
+    context 'when the server closes the old channel concurrently' do
+      it 'opens a new channel anyway' do
+        allow(old_channel).to receive(:close).
+          and_raise(Hutch::Adapter::ChannelAlreadyClosed.new('already closed', old_channel))
+
+        broker.replace_channel!
+
+        expect(broker.channel).to eq(new_channel)
+      end
+    end
+  end
+
+  describe 'acknowledgements' do
+    let(:current_channel) { double('Channel').as_null_object }
+    let(:superseded_channel) { double('Channel') }
+
+    before { broker.channel = current_channel }
+
+    it 'sends them on the channel the delivery arrived on' do
+      expect(current_channel).to receive(:ack).with('dt', false)
+      broker.ack('dt', channel: current_channel)
+
+      expect(current_channel).to receive(:nack).with('dt', false, false)
+      broker.nack('dt', channel: current_channel)
+
+      expect(current_channel).to receive(:reject).with('dt', false)
+      broker.reject('dt', channel: current_channel)
+
+      expect(current_channel).to receive(:reject).with('dt', true)
+      broker.requeue('dt', channel: current_channel)
+    end
+
+    it 'drops them when the channel has been replaced' do
+      expect(superseded_channel).not_to receive(:ack)
+      expect(superseded_channel).not_to receive(:nack)
+      expect(superseded_channel).not_to receive(:reject)
+
+      broker.ack('dt', channel: superseded_channel)
+      broker.nack('dt', channel: superseded_channel)
+      broker.reject('dt', channel: superseded_channel)
+      broker.requeue('dt', channel: superseded_channel)
+    end
+
+    it 'defaults to the current channel' do
+      expect(current_channel).to receive(:ack).with('dt', false)
+
+      broker.ack('dt')
+    end
+  end
+
   describe '#declare_exchange' do
     before do
       broker.open_connection!
@@ -211,9 +409,9 @@ describe Hutch::Broker do
     context 'when given invalid details' do
       before { config[:mq_api_host] = 'notarealhost' }
       after  { broker.disconnect }
-      let(:set_up_api_connection) { ->{ broker.set_up_api_connection } }
+      let(:set_up_api_connection) { broker.set_up_api_connection }
 
-      specify { expect(set_up_api_connection).to raise_error(StandardError) }
+      specify { expect { broker.set_up_api_connection }.to raise_error(StandardError) }
     end
   end
 
@@ -222,13 +420,27 @@ describe Hutch::Broker do
     let(:arguments) { { foo: :bar } }
     before { allow(broker).to receive(:channel) { channel } }
 
-    it 'applies a global namespace' do
-      config[:namespace] = 'mirror-all.service'
-      expect(broker.channel).to receive(:queue) do |*args|
-        args.first == ''
-        args.last == arguments
+    it 'creates a queue with the given name' do
+      expect(broker.channel).to receive(:queue).with('test', arguments: arguments)
+      broker.queue('test'.freeze, arguments: arguments)
+    end
+  end
+
+  describe '#namespaced_queue_name' do
+    context 'with a namespace configured' do
+      before { config[:namespace] = 'mirror-all.service' }
+
+      it 'prepends the namespace' do
+        expect(broker.namespaced_queue_name('test')).to eq('mirror-all.service:test')
+      end
+    end
+
+    context 'without a namespace configured' do
+      before { config[:namespace] = nil }
+
+      it 'returns the name unchanged' do
+        expect(broker.namespaced_queue_name('test')).to eq('test')
       end
-      broker.queue('test', arguments)
     end
   end
 
@@ -245,7 +457,7 @@ describe Hutch::Broker do
 
     context 'with a binding' do
       around do |example|
-        queue = broker.queue('test').bind(broker.exchange, routing_key: 'key')
+        queue = broker.queue('test', durable: true).bind(broker.exchange, routing_key: 'key')
         example.run
         queue.unbind(broker.exchange, routing_key: 'key').delete
       end
@@ -275,7 +487,7 @@ describe Hutch::Broker do
     end
 
     context '(rabbitmq integration test)', rabbitmq: true do
-      let(:queue) { broker.queue('consumer') }
+      let(:queue) { broker.queue('consumer', durable: true) }
       let(:routing_key) { 'key' }
 
       before { allow(broker).to receive(:bindings).and_call_original }