hutch 0.25.0-java → 2.0.0-java

data/lib/hutch/broker.rb

@@ -1,3 +1,4 @@
+require 'uri'
 require 'active_support/core_ext/object/blank'
 
 require 'carrot-top'
@@ -113,6 +114,8 @@ module Hutch
           logger.info 'enabling publisher confirms'
           ch.confirm_select
         end
+
+        connection.install_channel_recovery(ch)
       end
     end
 
@@ -120,13 +123,23 @@ module Hutch
       @channel = open_channel
     end
 
+    # Closing the old channel makes RabbitMQ forget the consumers on it
+    # and requeue their unacknowledged deliveries.
+    def replace_channel!
+      close_consumer_channel
+      open_channel!
+      declare_exchange!
+      declare_publisher!
+    end
+
     def declare_exchange(ch = channel)
       exchange_name = @config[:mq_exchange]
+      exchange_type = @config[:mq_exchange_type]
       exchange_options = { durable: true }.merge(@config[:mq_exchange_options])
       logger.info "using topic exchange '#{exchange_name}'"
 
       with_bunny_precondition_handler('exchange') do
-        ch.topic(exchange_name, exchange_options)
+        Adapter.new_exchange(ch, exchange_type, exchange_name, exchange_options)
       end
     end
 
@@ -169,24 +182,35 @@ module Hutch
       @config[:tracer] && @config[:tracer] != Hutch::Tracers::NullTracer
     end
 
-    # Create / get a durable queue and apply namespace if it exists.
-    def queue(name, arguments = {})
+    # Create / get a durable queue.
+    def queue(name, options = {})
       with_bunny_precondition_handler('queue') do
-        namespace = @config[:namespace].to_s.downcase.gsub(/[^-_:\.\w]/, "")
-        name = name.prepend(namespace + ":") if namespace.present?
-        channel.queue(name, durable: true, arguments: arguments)
+        channel.queue(name, **options)
       end
     end
 
+    def queue_exists?(name)
+      connection.queue_exists?(name)
+    end
+
+    # Apply the configured namespace prefix to a queue name.
+    def namespaced_queue_name(name)
+      namespace = @config[:namespace].to_s.downcase.gsub(/[^-_:\.\w]/, "")
+      namespace.present? ? "#{namespace}:#{name}" : name
+    end
+
     # Return a mapping of queue names to the routing keys they're bound to.
     def bindings
       results = Hash.new { |hash, key| hash[key] = [] }
-      api_client.bindings.each do |binding|
-        next if binding['destination'] == binding['routing_key']
-        next unless binding['source'] == @config[:mq_exchange]
-        next unless binding['vhost'] == @config[:mq_vhost]
+
+      filtered = api_client.bindings.
+        reject { |b| b['destination'] == b['routing_key'] }.
+        select { |b| b['source'] == @config[:mq_exchange] && b['vhost'] == vhost }
+
+      filtered.each do |binding|
         results[binding['destination']] << binding['routing_key']
       end
+
       results
     end
 
@@ -194,8 +218,8 @@ module Hutch
     def unbind_redundant_bindings(queue, routing_keys)
       return unless http_api_use_enabled?
 
-      bindings.each do |dest, keys|
-        next unless dest == queue.name
+      filtered = bindings.select { |dest, keys| dest == queue.name }
+      filtered.each do |dest, keys|
         keys.reject { |key| routing_keys.include?(key) }.each do |key|
           logger.debug "removing redundant binding #{queue.name} <--> #{key}"
           queue.unbind(exchange, routing_key: key)
@@ -220,29 +244,26 @@ module Hutch
       if defined?(JRUBY_VERSION)
         channel.close
       else
-        # Enqueue a failing job that kills the consumer loop
-        channel_work_pool.shutdown
-        # Give `timeout` seconds to jobs that are still being processed
-        channel_work_pool.join(@config[:graceful_exit_timeout])
-        # If after `timeout` they are still running, they are killed
-        channel_work_pool.kill
+        drain_consumer_work_pool
       end
     end
 
-    def requeue(delivery_tag)
-      channel.reject(delivery_tag, true)
+    # Delivery tags are scoped to their channel: a tag from a replaced one
+    # is dropped, the server has requeued that delivery anyway.
+    def requeue(delivery_tag, channel: self.channel)
+      channel.reject(delivery_tag, true) if current_channel?(channel)
     end
 
-    def reject(delivery_tag, requeue=false)
-      channel.reject(delivery_tag, requeue)
+    def reject(delivery_tag, requeue = false, channel: self.channel)
+      channel.reject(delivery_tag, requeue) if current_channel?(channel)
     end
 
-    def ack(delivery_tag)
-      channel.ack(delivery_tag, false)
+    def ack(delivery_tag, channel: self.channel)
+      channel.ack(delivery_tag, false) if current_channel?(channel)
     end
 
-    def nack(delivery_tag)
-      channel.nack(delivery_tag, false, false)
+    def nack(delivery_tag, channel: self.channel)
+      channel.nack(delivery_tag, false, false) if current_channel?(channel)
     end
 
     def publish(*args)
@@ -264,15 +285,39 @@ module Hutch
 
     private
 
+    def current_channel?(ch)
+      ch.equal?(channel)
+    end
+
+    def close_consumer_channel
+      return unless @channel && @channel.open?
+
+      drain_consumer_work_pool unless defined?(JRUBY_VERSION)
+      @channel.close
+    rescue Hutch::Adapter::ChannelAlreadyClosed
+      # The server closed the channel first: same outcome.
+    end
+
+    # Bunny kills the consumer work pool when the channel closes. Draining
+    # first gives the running handlers `graceful_exit_timeout` to finish.
+    def drain_consumer_work_pool
+      channel_work_pool.shutdown
+      channel_work_pool.join(@config[:graceful_exit_timeout])
+      channel_work_pool.kill
+    end
+
+    Config = Struct.new(:host, :port, :username, :password, :ssl, :protocol, :sanitized_uri)
+    private_constant :Config
+
     def api_config
-      @api_config ||= OpenStruct.new.tap do |config|
+      @api_config ||= Config.new.tap do |config|
         config.host = @config[:mq_api_host]
         config.port = @config[:mq_api_port]
         config.username = @config[:mq_username]
         config.password = @config[:mq_password]
         config.ssl = @config[:mq_api_ssl]
         config.protocol = config.ssl ? "https://" : "http://"
-        config.sanitized_uri = "#{config.protocol}#{config.username}@#{config.host}:#{config.port}/"
+        config.sanitized_uri = "#{config.protocol}#{URI.encode_uri_component(config.username.to_s)}@#{config.host}:#{config.port}/"
       end
     end
 
@@ -282,7 +327,8 @@ module Hutch
       {}.tap do |params|
         params[:host]               = @config[:mq_host]
         params[:port]               = @config[:mq_port]
-        params[:vhost]              = @config[:mq_vhost].presence || Hutch::Adapter::DEFAULT_VHOST
+        params[:vhost]              = vhost
+        params[:auth_mechanism]     = @config[:mq_auth_mechanism]
         params[:username]           = @config[:mq_username]
         params[:password]           = @config[:mq_password]
         params[:tls]                = @config[:mq_tls]
@@ -293,13 +339,15 @@ module Hutch
           params[:tls_ca_certificates] = @config[:mq_tls_ca_certificates]
         end
         params[:heartbeat]          = @config[:heartbeat]
+        params[:client_properties]  = @config[:mq_client_properties]
+        params[:connection_name]    = @config[:connection_name]
         params[:connection_timeout] = @config[:connection_timeout]
         params[:read_timeout]       = @config[:read_timeout]
         params[:write_timeout]      = @config[:write_timeout]
 
 
-        params[:automatically_recover] = true
-        params[:network_recovery_interval] = 1
+        params[:automatically_recover] = @config[:automatically_recover]
+        params[:network_recovery_interval] = @config[:network_recovery_interval]
 
         params[:logger] = @config[:client_logger] if @config[:client_logger]
       end
@@ -313,9 +361,23 @@ module Hutch
       @config[:mq_tls]      = u.scheme == 'amqps'
       @config[:mq_host]     = u.host
       @config[:mq_port]     = u.port || default_mq_port
-      @config[:mq_vhost]    = u.path.sub(/^\//, "")
-      @config[:mq_username] = u.user
-      @config[:mq_password] = u.password
+      @config[:mq_vhost]    = parse_vhost(u)
+      @config[:mq_username] = u.user && URI.decode_uri_component(u.user)
+      @config[:mq_password] = u.password && URI.decode_uri_component(u.password)
+    end
+
+    # Resolved here rather than in #connection_params, so that
+    # Config[:mq_vhost] holds the name the HTTP API reports too.
+    def parse_vhost(uri)
+      URI.decode_uri_component(uri.path.sub(%r{\A/}, "")).presence ||
+        Hutch::Adapter::DEFAULT_VHOST
+    end
+
+    # The vhost Hutch connects to. Config[:mq_vhost] can still be blank when it
+    # was set directly rather than through a URI, while the broker and its HTTP
+    # API call the default vhost `/`.
+    def vhost
+      @config[:mq_vhost].presence || Hutch::Adapter::DEFAULT_VHOST
     end
 
     def default_mq_port
@@ -326,7 +388,8 @@ module Hutch
       p = connection_params
       scheme = p[:tls] ? "amqps" : "amqp"
 
-      "#{scheme}://#{p[:username]}@#{p[:host]}:#{p[:port]}/#{p[:vhost].sub(/^\//, '')}"
+      "#{scheme}://#{URI.encode_uri_component(p[:username].to_s)}" \
+        "@#{p[:host]}:#{p[:port]}/#{URI.encode_uri_component(p[:vhost].sub(%r{\A/}, ''))}"
     end
 
     def with_authentication_error_handler

data/lib/hutch/cli.rb

@@ -33,6 +33,20 @@ module Hutch
     def load_app
       # Try to load a Rails app in the current directory
       load_rails_app('.') if Hutch::Config.autoload_rails
+      set_up_code_paths!
+
+      # Because of the order things are required when we run the Hutch binary
+      # in hutch/bin, the sentry-ruby gem gets required **after** the error
+      # handlers are set up. Due to this, we never got any Sentry notifications
+      # when an error occurred in any of the consumers.
+      if defined?(Sentry)
+        Hutch::Config[:error_handlers] << Hutch::ErrorHandlers::Sentry.new
+      end
+
+      true
+    end
+
+    def set_up_code_paths!
       Hutch::Config.require_paths.each do |path|
         # See if each path is a Rails app. If so, try to load it.
         next if load_rails_app(path)
@@ -48,19 +62,9 @@ module Hutch
           return false
         ensure
           # Clean up load path
-          $LOAD_PATH.pop
+          $LOAD_PATH.delete('.')
         end
       end
-
-      # Because of the order things are required when we run the Hutch binary
-      # in hutch/bin, the Sentry Raven gem gets required **after** the error
-      # handlers are set up. Due to this, we never got any Sentry notifications
-      # when an error occurred in any of the consumers.
-      if defined?(Raven)
-        Hutch::Config[:error_handlers] << Hutch::ErrorHandlers::Sentry.new
-      end
-
-      true
     end
 
     def load_rails_app(path)
@@ -227,7 +231,7 @@ module Hutch
     end
 
     def abort_without_file(file, file_description, &block)
-      abort_with_message("#{file_description} '#{file}' not found") unless File.exists?(file)
+      abort_with_message("#{file_description} '#{file}' not found") unless File.exist?(file)
 
       yield
     end

data/lib/hutch/config.rb

@@ -49,17 +49,23 @@ module Hutch
     # RabbitMQ Exchange to use for publishing
     string_setting :mq_exchange, 'hutch'
 
+    # RabbitMQ Exchange type to use for publishing
+    string_setting :mq_exchange_type, 'topic'
+
     # RabbitMQ vhost to use
     string_setting :mq_vhost, '/'
 
     # RabbitMQ username to use.
     #
-    # As of RabbitMQ 3.3.0, <tt>guest</tt> can only can connect from localhost.
+    # The <tt>guest</tt> user can only connect from localhost.
     string_setting :mq_username, 'guest'
 
     # RabbitMQ password
     string_setting :mq_password, 'guest'
 
+    # RabbitMQ Auth Mechanism
+    string_setting :mq_auth_mechanism, 'PLAIN'
+
     # RabbitMQ URI (takes precedence over MQ username, password, host, port and vhost settings)
     string_setting :uri, nil
 
@@ -72,7 +78,7 @@ module Hutch
     # RabbitMQ HTTP API port
     number_setting :mq_api_port, 15672
 
-    # [RabbitMQ heartbeat timeout](http://rabbitmq.com/heartbeats.html)
+    # [RabbitMQ heartbeat timeout](https://www.rabbitmq.com/docs/heartbeats)
     number_setting :heartbeat, 30
 
     # The <tt>basic.qos</tt> prefetch value to use.
@@ -80,6 +86,9 @@ module Hutch
     # Default: `0`, no limit. See Bunny and RabbitMQ documentation.
     number_setting :channel_prefetch, 0
 
+    # [Client-Provided Connection Name](https://www.rabbitmq.com/docs/connections#client-provided-names)
+    string_setting :connection_name, nil
+
     # Bunny's socket open timeout
     number_setting :connection_timeout, 11
 
@@ -89,7 +98,13 @@ module Hutch
     # Bunny's socket write timeout
     number_setting :write_timeout, 11
 
-    # FIXME: DOCUMENT THIS
+    # Bunny's enable/disable network recovery
+    boolean_setting :automatically_recover, true
+
+    # Bunny's reconnect interval
+    number_setting :network_recovery_interval, 1
+
+    # Timeout (in seconds) for consumer threads to finish before being killed during graceful shutdown
     number_setting :graceful_exit_timeout, 11
 
     # Bunny consumer work pool size
@@ -136,6 +151,9 @@ module Hutch
     # Prefix displayed on the consumers tags.
     string_setting :consumer_tag_prefix, 'hutch'
 
+    # A namespace to help group your queues
+    string_setting :namespace, nil
+
     string_setting :group, ''
 
     # Set of all setting keys
@@ -156,6 +174,7 @@ module Hutch
     # @return [Hash]
     def self.default_config
       @settings_defaults.merge({
+        mq_client_properties: {},
         mq_exchange_options: {},
         mq_tls_cert: nil,
         mq_tls_key: nil,
@@ -184,14 +203,7 @@ module Hutch
       env_keys_configured.each_with_object({}) {|attr, result|
         value = ENV[key_for(attr)]
 
-        case
-        when is_bool(attr) || value == 'false'
-          result[attr] = to_bool(value)
-        when is_num(attr)
-          result[attr] = value.to_i
-        else
-          result[attr] = value
-        end
+        result[attr] = type_cast(attr, value)
       }
     end
 
@@ -217,7 +229,12 @@ module Hutch
     end
 
     def self.to_bool(value)
-      !(value.nil? || value == '' || value =~ /^(false|f|no|n|0)$/i || value == false)
+      case value
+      when nil, false, '', /^(false|f|no|n|0)$/i
+        false
+      else
+        true
+      end
     end
 
     def self.is_num(attr)
@@ -226,7 +243,7 @@ module Hutch
 
     def self.set(attr, value)
       check_attr(attr.to_sym)
-      user_config[attr.to_sym] = value
+      user_config[attr.to_sym] = type_cast(attr, value)
     end
 
     class << self
@@ -263,6 +280,18 @@ module Hutch
       end
     end
 
+    def self.type_cast(attr, value)
+      case
+      when is_bool(attr) || value == 'false'
+        to_bool(value)
+      when is_num(attr)
+        value.to_i
+      else
+        value
+      end
+    end
+    private_class_method :type_cast
+
     def self.define_methods
       @config.keys.each do |key|
         define_singleton_method(key) do

data/lib/hutch/consumer.rb

@@ -13,11 +13,17 @@ module Hutch
     end
 
     def reject!
-      broker.reject(delivery_info.delivery_tag)
+      @message_rejected = true
+      broker.reject(delivery_info.delivery_tag, channel: delivery_info.channel)
     end
 
     def requeue!
-      broker.requeue(delivery_info.delivery_tag)
+      @message_rejected = true
+      broker.requeue(delivery_info.delivery_tag, channel: delivery_info.channel)
+    end
+
+    def message_rejected?
+      !!@message_rejected
     end
 
     def logger
@@ -29,18 +35,56 @@ module Hutch
       # wants to subscribe to.
       def consume(*routing_keys)
         @routing_keys = self.routing_keys.union(routing_keys)
+        # these are opt-in
+        @queue_mode = nil
+        @queue_type = nil
       end
 
+      attr_reader :queue_mode, :queue_type, :initial_group_size
+
       # Explicitly set the queue name
       def queue_name(name)
         @queue_name = name
       end
 
-      # Allow to specify custom arguments that will be passed when creating the queue.
+      # Opt out of the namespace prefix for this consumer's queue
+      def without_namespace
+        @without_namespace = true
+      end
+
+      def without_namespace?
+        !!@without_namespace
+      end
+
+      # Explicitly set the queue mode to 'lazy'
+      def lazy_queue
+        @queue_mode = 'lazy'
+      end
+
+      # Explicitly set the queue type to 'classic'
+      def classic_queue
+        @queue_type = 'classic'
+      end
+
+      # Explicitly set the queue type to 'quorum'
+      # @param [Hash] options the options params related to quorum queue
+      # @option options [Integer] :initial_group_size Initial Replication Factor
+      def quorum_queue(options = {})
+        @queue_type = 'quorum'
+        @initial_group_size = options[:initial_group_size]
+      end
+
+      # Configures an optional argument that will be passed when declaring the queue.
+      # Prefer using a policy to this DSL: https://www.rabbitmq.com/parameters.html#policies
       def arguments(arguments = {})
         @arguments = arguments
       end
 
+      # Configures queue options that will be passed when declaring the queue.
+      def queue_options(options = {})
+        @queue_options = options
+      end
+
       # Set custom serializer class, override global value
       def serializer(name)
         @serializer = name
@@ -58,7 +102,22 @@ module Hutch
 
       # Returns consumer custom arguments.
       def get_arguments
-        @arguments || {}
+        all_arguments = @arguments || {}
+
+        all_arguments['x-queue-mode'] = @queue_mode if @queue_mode
+        all_arguments['x-queue-type'] = @queue_type if @queue_type
+        all_arguments['x-quorum-initial-group-size'] = @initial_group_size if @initial_group_size
+
+        all_arguments
+      end
+
+      def get_options
+        default_options = { durable: true }
+
+        all_options = default_options.merge(@queue_options || {})
+        all_options[:arguments] = get_arguments
+
+        all_options
       end
 
       # Accessor for the consumer's routing key.

data/lib/hutch/error_handlers/bugsnag.rb

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

data/lib/hutch/error_handlers/{opbeat.rb → rollbar.rb}

@@ -1,29 +1,27 @@
 require 'hutch/logging'
-require 'opbeat'
+require 'rollbar'
 require 'hutch/error_handlers/base'
 
 module Hutch
   module ErrorHandlers
-    class Opbeat < Base
-
-      def initialize
-        unless ::Opbeat.respond_to?(:report)
-          raise "The Opbeat error handler requires Opbeat >= 3.0"
-        end
-      end
-
+    class Rollbar < Base
       def handle(properties, payload, consumer, ex)
         message_id = properties.message_id
         prefix = "message(#{message_id || '-'}):"
-        logger.error "#{prefix} Logging event to Opbeat"
+        logger.error "#{prefix} Logging event to Rollbar"
         logger.error "#{prefix} #{ex.class} - #{ex.message}"
-        ::Opbeat.report(ex, extra: { payload: payload })
+
+        ::Rollbar.error(ex,
+          payload: payload,
+          consumer: consumer
+        )
       end
 
       def handle_setup_exception(ex)
-        logger.error "Logging setup exception to Opbeat"
+        logger.error "Logging setup exception to Rollbar"
         logger.error "#{ex.class} - #{ex.message}"
-        ::Opbeat.report(ex)
+
+        ::Rollbar.error(ex)
       end
     end
   end

data/lib/hutch/error_handlers/sentry.rb

@@ -1,31 +1,26 @@
 require 'hutch/logging'
-require 'raven'
+require 'sentry-ruby'
 require 'hutch/error_handlers/base'
 
 module Hutch
   module ErrorHandlers
     class Sentry < Base
-
-      def initialize
-        unless Raven.respond_to?(:capture_exception)
-          raise "The Hutch Sentry error handler requires Raven >= 0.4.0"
-        end
-      end
-
       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}"
-        Raven.capture_exception(ex)
+        ::Sentry.capture_exception(ex)
       end
-
     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