hutch 1.4.0 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9ca80c1f8e42d188755ed5bc94834a841a3935f962e977f3fe01bc17753bdf7
-  data.tar.gz: '0149d00db0ebe07503caf6fd955a051cbc71581e2190a44f91c1128a9ebc3744'
+  metadata.gz: 8978faf08cf85e68cc957d91ff3059b0b3fecb73e018a80ec551c9547be9c99a
+  data.tar.gz: 2c1f461463321e705e2464373093135bf307b68dac9f08b284e8c5f6c9e710db
 SHA512:
-  metadata.gz: 5f1432e36ee499275c334b3f39268f2907ab842e766cc0dded754abeaca771692e7a11be8ef3d48c3c2f6e6a6ba1690de5ac5381db5dd0d1cde00cb1f65d7ffa
-  data.tar.gz: 16d5ef22b69e7468e097a2dacb49b736d27245e586767e013763f577bf69918f0b44f507ddc59c90ba116e9d473eeba3a5acdd8a95cb4b7407d5c899cadc0ebb
+  metadata.gz: 8900ac9233d8849f789b2f598e8109d8bcc7aab3bc7870c00d881e47aaa6f3a3722b906a018c8c8f6dd0b69258a15f7f7654027a216429a9bfe2639f53070100
+  data.tar.gz: e3c8b5ac42f24483a773167eb79d01e9e29e71859c0a78ccf01d59b018ec1f57a1a5c26c8da47ad9ebb743b04fed9d67989802eb0f495bd894c1b3c51cb830c3

data/CHANGELOG.md

@@ -1,3 +1,64 @@
+# Hutch Change Log
+
+## 2.0.0 (TBD)
+
+### Breaking Changes
+
+ * Ruby `3.2` or JRuby `10` is now required
+ * The Datadog tracer now depends on the [`datadog`](https://github.com/DataDog/dd-trace-rb)
+   gem, which replaces the EOL `ddtrace`
+   ([migration guide](https://github.com/DataDog/dd-trace-rb/blob/master/docs/UpgradeGuide2.md))
+ * `Hutch::ErrorHandlers::SentryRaven` has been replaced by
+   `Hutch::ErrorHandlers::Sentry`, backed by `sentry-ruby`
+   ([migration guide](https://docs.sentry.io/platforms/ruby/migration/))
+ * Messages are serialized with the stdlib `json` instead of `multi_json`, which
+   means that `MultiJson` configuration such as `MultiJson.use(:oj)` no longer
+   affects Hutch
+
+### Consumer Recovery After a RabbitMQ 4.3 Quorum Queue Consumer Timeout
+
+RabbitMQ 4.3 quorum queues cancel a timed out consumer with `basic.cancel`
+instead of closing the channel. Hutch 1.4.0 does not react to that, so on 4.3
+a consumer stops consuming its queue until the worker restarts.
+
+Workers now re-subscribe consumers cancelled by the server, but only if
+the queue still exists: a `basic.cancel` carries no reason, so a consumer
+timeout is indistinguishable from a queue deletion. The consumer channel is
+replaced in the process, so the deliveries the cancelled consumer still held
+are requeued instead of dropped.
+
+Handlers that are still running get a graceful exit to finish before
+the old channel is closed, and their acknowledgements are dropped rather than
+sent on the new channel, where their delivery tags mean nothing.
+
+### Connection URIs Are Now Percent-Decoded
+
+The virtual host, username and password of a connection URI are now decoded, as
+[the URI specification](https://www.rabbitmq.com/docs/uri-spec) requires.
+`amqp://host/%2F` connects to the default virtual host instead of one literally
+named `%2F`, and credentials containing a space, `#` or `@` authenticate again.
+
+Reported by @deissimon.
+
+GitHub issue: [#422](https://github.com/ruby-amqp/hutch/issues/422)
+
+### Fixed Two JRuby Regressions
+
+Opening a channel raised, and the `march_hare` adapter did not declare the
+exchange it instantiated.
+
+GitHub issue: [#427](https://github.com/ruby-amqp/hutch/issues/427)
+
+### The JRuby Variant Is Revived
+
+The `java` platform gem, which depends on March Hare instead of Bunny, was last
+published as `0.25.0` in January 2018 and has seen little more than CI version
+bumps since. This release requires JRuby `10` and `march_hare` `4.7.0`, adds a
+JRuby CI job, and publishes the gem again.
+
+Recovering a channel the broker closed remains Bunny-only: `MarchHare::Channel`
+has no `on_error` callback and no `reopen`.
+
 ## 1.4.0 (Apr 7, 2026)
 
 ### Ruby 3.0 is Now Required

data/LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2013-2016 GoCardless
-Copyright (c) 2016-2021 Hutch contributors
+Copyright (c) 2016-2026 Hutch contributors
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README.md

@@ -1,7 +1,5 @@
-![](http://cl.ly/image/3h0q3F3G142K/hutch.png)
-
-[![Gem Version](https://badge.fury.io/rb/hutch.svg)](http://badge.fury.io/rb/hutch)
-[![Code Climate](https://codeclimate.com/github/gocardless/hutch.svg)](https://codeclimate.com/github/gocardless/hutch)
+[![Gem Version](https://badge.fury.io/rb/hutch.svg)](https://badge.fury.io/rb/hutch)
+[![CI](https://github.com/ruby-amqp/hutch/actions/workflows/test.yml/badge.svg)](https://github.com/ruby-amqp/hutch/actions/workflows/test.yml)
 
 Hutch is a Ruby library for enabling asynchronous inter-service communication
 in a service-oriented architecture, using RabbitMQ.
@@ -23,6 +21,8 @@ gem install hutch
     - [Message Processing Tracers](#message-processing-tracers)
   - [Running Hutch](#running-hutch)
     - [Loading Consumers](#loading-consumers)
+    - [Consumer Groups](#consumer-groups)
+    - [Loading Consumers Manually (One-by-One)](#loading-consumers-manually-one-by-one)
     - [Stopping Hutch](#stopping-hutch)
   - [Producers](#producers)
     - [Producer Configuration](#producer-configuration)
@@ -38,8 +38,8 @@ gem install hutch
 
 ## Requirements
 
-- Hutch requires Ruby 2.4+ or JRuby 9K.
-- Hutch requires RabbitMQ 3.3 or later.
+- Hutch requires Ruby 3.2+ or JRuby 10+
+- Hutch requires RabbitMQ 3.13 or later
 
 ## Overview
 
@@ -52,7 +52,7 @@ With Hutch, consumers are stored in separate files and include the `Hutch::Consu
 They are then loaded by a command line runner which connects to RabbitMQ, sets up queues and bindings,
 and so on. Publishers connect to RabbitMQ via `Hutch.connect` and publish using `Hutch.publish`.
 
-Hutch uses [Bunny](http://rubybunny.info) or [March Hare](http://rubymarchhare.info)
+Hutch uses [Bunny](https://github.com/ruby-amqp/bunny) or [March Hare](https://github.com/ruby-amqp/march_hare)
 (on JRuby) under the hood.
 
 ### Project Maturity
@@ -79,7 +79,7 @@ message[:id]  # => "02ABCXYZ"
 To subscribe to a topic, pass a routing key to `consume` in the class
 definition. To bind to multiple routing keys, simply pass extra routing keys
 in as additional arguments. Refer to the [RabbitMQ docs on topic exchanges
-](http://www.rabbitmq.com/tutorials/tutorial-five-ruby.html) for more information
+](https://www.rabbitmq.com/tutorials/tutorial-five-ruby) for more information
 about how to use routing keys. Here's an example consumer:
 
 ```ruby
@@ -110,10 +110,10 @@ end
 
 It is possible to set some custom options to consumer's queue explicitly.
 This example sets the consumer's queue as a
-[quorum queue](https://www.rabbitmq.com/quorum-queues.html)
-and to operate in the [lazy mode](https://www.rabbitmq.com/lazy-queues.html).
+[quorum queue](https://www.rabbitmq.com/docs/quorum-queues)
+and to operate in the [lazy mode](https://www.rabbitmq.com/docs/lazy-queues).
 The `initial_group_size`
-[argument](https://www.rabbitmq.com/quorum-queues.html#replication-factor) is
+[argument](https://www.rabbitmq.com/docs/quorum-queues#replication-factor) is
 optional.
 
 ```ruby
@@ -142,11 +142,11 @@ end
 ```
 
 This sets the `x-max-length` header. For more details, see the [RabbitMQ
-documentation on Queue Length Limit](https://www.rabbitmq.com/maxlength.html). To find out more
-about custom queue arguments, consult the [RabbitMQ documentation on AMQP Protocol Extensions](https://www.rabbitmq.com/extensions.html).
+documentation on Queue Length Limit](https://www.rabbitmq.com/docs/maxlength). To find out more
+about custom queue arguments, consult the [RabbitMQ documentation on AMQP Protocol Extensions](https://www.rabbitmq.com/docs/extensions).
 
 Consumers can write to Hutch's log by calling the logger method. The logger method returns
-a [Logger object](http://ruby-doc.org/stdlib-2.1.2/libdoc/logger/rdoc/Logger.html).
+a [Logger object](https://docs.ruby-lang.org/en/3.0/Logger.html).
 
 ```ruby
 class FailedPaymentConsumer
@@ -174,7 +174,7 @@ client_logger = Logger.new("/path/to/bunny.log")
 Hutch::Config.set(:client_logger, client_logger)
 ```
 
-See this [RabbitMQ tutorial on topic exchanges](http://www.rabbitmq.com/tutorials/tutorial-five-ruby.html)
+See this [RabbitMQ tutorial on topic exchanges](https://www.rabbitmq.com/tutorials/tutorial-five-ruby)
 to learn more.
 
 ### Message Processing Tracers
@@ -206,7 +206,7 @@ usage: hutch [options]
         --mq-host HOST               Set the RabbitMQ host
         --mq-port PORT               Set the RabbitMQ port
     -t, --[no-]mq-tls                Use TLS for the AMQP connection
-        --mq-tls-cert FILE           Certificate  for TLS client verification
+        --mq-tls-cert FILE           Certificate for TLS client verification
         --mq-tls-key FILE            Private key for TLS client verification
         --mq-exchange EXCHANGE       Set the RabbitMQ exchange
         --mq-vhost VHOST             Set the RabbitMQ vhost
@@ -242,13 +242,13 @@ in the config file, allowing for easy customization.
 
 Using Hutch with a Rails app is simple. Either start Hutch in the working
 directory of a Rails app, or pass the path to a Rails app in with the
-`--require` option. Consumers defined in Rails apps should be placed with in
+`--require` option. Consumers defined in Rails apps should be placed within
 the `app/consumers/` directory, to allow them to be auto-loaded when Rails
 boots.
 
-If you're using the new Zeitwerk autoloader (enabled by default in Rails 6)
-and the consumers are not loaded in development environment you will need to
-trigger the autoloading in an initializer with
+If you're using the Zeitwerk autoloader (the default since Rails 6)
+and the consumers are not loaded in the development environment, you will need to
+trigger eager loading in an initializer with
 
 ```ruby
 ::Zeitwerk::Loader.eager_load_all
@@ -309,8 +309,6 @@ kill -SIGTERM 456 # or kill -15 456
 kill -SIGQUIT 789 # or kill -3 789
 ```
 
-![](http://g.recordit.co/wyCdzG9Kh3.gif)
-
 ## Producers
 
 Hutch includes a `publish` method for sending messages to Hutch consumers. When
@@ -334,7 +332,7 @@ Hutch::Config.set(:mq_exchange, 'name')
 ### Publisher Confirms
 
 For maximum message reliability when producing messages, you can force Hutch to use
-[Publisher Confirms](https://www.rabbitmq.com/confirms.html) and wait for a confirmation
+[Publisher Confirms](https://www.rabbitmq.com/docs/confirms) and wait for a confirmation
 after every message published. This is the safest possible option for publishers
 but also results in a **significant throughput drop**.
 
@@ -354,25 +352,27 @@ send messages to Hutch.
 - Hutch works with topic exchanges, check the producer is also using topic
   exchanges.
 - Use message routing keys that match those used in your Hutch consumers.
-- Be sure your exchanges are marked as durable. In the Ruby AMQP gem, this is
-  done by passing `durable: true` to the exchange creation method.
-- Publish messages as persistent.
-- Using publisher confirms is highly recommended.
+- Be sure your exchanges are marked as durable, by passing `durable: true`
+  to the exchange creation method
+- Publish messages as persistent
+- Using publisher confirms is highly recommended
 
 Here's an example of a well-behaved publisher, minus publisher confirms:
 
 ```ruby
-AMQP.connect(host: config[:host]) do |connection|
-  channel  = AMQP::Channel.new(connection)
-  exchange = channel.topic(config[:exchange], durable: true)
+require 'bunny'
 
-  message = JSON.dump({ subject: 'Test', id: 'abc' })
-  exchange.publish(message, routing_key: 'test', persistent: true)
-end
-```
+conn = Bunny.new(host: config[:host])
+conn.start
 
-If using publisher confirms with amqp gem, see [this issue](https://github.com/ruby-amqp/amqp/issues/92)
-and [this gist](https://gist.github.com/3042381) for more info.
+ch       = conn.create_channel
+exchange = ch.topic(config[:exchange], durable: true)
+
+message = JSON.dump({ subject: 'Test', id: 'abc' })
+exchange.publish(message, routing_key: 'test', persistent: true)
+
+conn.close
+```
 
 ## Configuration
 
@@ -385,7 +385,7 @@ Known configuration parameters are:
  * `mq_host`: RabbitMQ hostname (default: `localhost`)
  * `mq_port`: RabbitMQ port (default: `5672`)
  * `mq_vhost`: vhost to use (default: `/`)
- * `mq_username`: username to use (default: `guest`, only can connect from localhost as of RabbitMQ 3.3.0)
+ * `mq_username`: username to use (default: `guest`, can only connect from localhost)
  * `mq_password`: password to use (default: `guest`)
  * `mq_tls`: should TLS be used? (default: `false`)
  * `mq_tls_cert`: path to client TLS certificate (public key)
@@ -407,7 +407,7 @@ Known configuration parameters are:
     exception happens, see classes in `Hutch::Acknowledgements`.
  * `mq_exchange`: exchange to use for publishing (default: `hutch`)
  * `mq_client_properties`: Bunny's [client properties](https://www.rabbitmq.com/docs/connections#capabilities) (default: `{}`)
- * `heartbeat`: [RabbitMQ heartbeat timeout](http://rabbitmq.com/heartbeats.html) (default: `30`)
+ * `heartbeat`: [RabbitMQ heartbeat timeout](https://www.rabbitmq.com/docs/heartbeats) (default: `30`)
  * `connection_timeout`: Bunny's socket open timeout (default: `11`)
  * `read_timeout`: Bunny's socket read timeout (default: `11`)
  * `write_timeout`: Bunny's socket write timeout (default: `11`)
@@ -534,7 +534,7 @@ Generate with
       <td>30</td>
       <td>Number</td>
       <td><tt>HUTCH_HEARTBEAT</tt></td>
-      <td><p><a href="http://rabbitmq.com/heartbeats.html">RabbitMQ heartbeat timeout</a></p></td>
+      <td><p><a href="https://www.rabbitmq.com/docs/heartbeats">RabbitMQ heartbeat timeout</a></p></td>
     </tr>
     <tr>
       <td><tt>channel_prefetch</tt></td>
@@ -590,7 +590,7 @@ Generate with
       <td>11</td>
       <td>Number</td>
       <td><tt>HUTCH_GRACEFUL_EXIT_TIMEOUT</tt></td>
-      <td><p>FIXME: DOCUMENT THIS</p></td>
+      <td><p>Timeout (in seconds) for consumer threads to finish before being killed during graceful shutdown</p></td>
     </tr>
     <tr>
       <td><tt>consumer_pool_size</tt></td>
@@ -646,7 +646,7 @@ Generate with
       <td>false</td>
       <td>Boolean</td>
       <td><tt>HUTCH_FORCE_PUBLISHER_CONFIRMS</tt></td>
-      <td><p>Enables publisher confirms, forces Hutch::Broker#wait_for_confirms for</p></td>
+      <td><p>Enables publisher confirms, forces Hutch::Broker#wait_for_confirms for every publish</p></td>
     </tr>
     <tr>
       <td><tt>enable_http_api_use</tt></td>
@@ -681,7 +681,7 @@ Generate with
       <td>''</td>
       <td>String</td>
       <td><tt>HUTCH_GROUP</tt></td>
-      <td></td>
+      <td><p>Consumer group to load (see Consumer Groups)</p></td>
     </tr>
   </tbody>
 </table>

data/lib/hutch/acknowledgements/nack_on_all_failures.rb

@@ -10,7 +10,7 @@ module Hutch
         prefix = "message(#{properties.message_id || '-'}): "
         logger.debug "#{prefix} nacking message"
 
-        broker.nack(delivery_info.delivery_tag)
+        broker.nack(delivery_info.delivery_tag, channel: delivery_info.channel)
 
         true
       end

data/lib/hutch/adapters/bunny.rb

@@ -1,14 +1,18 @@
 require 'bunny'
 require 'forwardable'
 
+require 'hutch/logging'
+
 module Hutch
   module Adapters
     class BunnyAdapter
       extend Forwardable
+      include Logging
 
       DEFAULT_VHOST = Bunny::Session::DEFAULT_VHOST
 
       ConnectionRefused = Bunny::TCPConnectionFailed
+      ChannelAlreadyClosed = Bunny::ChannelAlreadyClosed
       PreconditionFailed = Bunny::PreconditionFailed
 
       def_delegators :@connection, :start, :disconnect, :close, :create_channel, :open?, :recover_channel_topology
@@ -25,6 +29,26 @@ module Hutch
         ch.prefetch(prefetch) if prefetch
       end
 
+      def queue_exists?(name)
+        @connection.queue_exists?(name)
+      end
+
+      def install_channel_recovery(ch)
+        # A consumer timeout invalidates the delivery tag, so a handler that
+        # was still running acknowledges an unknown tag and closes the channel.
+        ch.on_error do |channel, close|
+          next unless close.delivery_ack_timeout? || close.unknown_delivery_tag?
+
+          begin
+            channel.reopen
+            recover_channel_topology(channel)
+            logger.warn "recovered consumer channel closed with '#{close.reply_text}'"
+          rescue => ex
+            logger.error "channel recovery failed: #{ex.class}: #{ex.message}"
+          end
+        end
+      end
+
       def current_timestamp
         Time.now.to_i
       end

data/lib/hutch/adapters/march_hare.rb

@@ -9,6 +9,7 @@ module Hutch
       DEFAULT_VHOST = "/"
 
       ConnectionRefused = MarchHare::ConnectionRefused
+      ChannelAlreadyClosed = MarchHare::ChannelAlreadyClosed
       PreconditionFailed = MarchHare::PreconditionFailed
 
       def_delegators :@connection, :start, :disconnect, :close, :open?
@@ -25,6 +26,25 @@ module Hutch
         ch.prefetch = prefetch if prefetch
       end
 
+      # `MarchHare::Session` has no `queue_exists?` counterpart, and a failed
+      # passive declare closes the channel, hence the throwaway one.
+      def queue_exists?(name)
+        ch = @connection.create_channel
+        begin
+          ch.queue(name, passive: true)
+          true
+        rescue MarchHare::NotFound
+          false
+        ensure
+          ch.close rescue nil
+        end
+      end
+
+      # MarchHare::Channel has no on_error callback, and neither Channel#reopen
+      # nor Session#recover_channel_topology has a `march_hare` counterpart.
+      def install_channel_recovery(ch)
+      end
+
       def create_channel(n = nil, consumer_pool_size = 1, consumer_pool_abort_on_exception = false)
         @connection.create_channel(n)
       end
@@ -34,7 +54,7 @@ module Hutch
       end
 
       def self.new_exchange(ch, exchange_type, exchange_name, exchange_options)
-        MarchHare::Exchange.new(ch, exchange_name, exchange_options.merge(type: exchange_type))
+        MarchHare::Exchange.new(ch, exchange_name, exchange_options.merge(type: exchange_type)).tap(&:declare!)
       end
     end
   end

data/lib/hutch/broker.rb

@@ -1,3 +1,4 @@
+require 'uri'
 require 'active_support/core_ext/object/blank'
 
 require 'carrot-top'
@@ -114,7 +115,7 @@ module Hutch
           ch.confirm_select
         end
 
-        install_channel_recovery!(ch)
+        connection.install_channel_recovery(ch)
       end
     end
 
@@ -122,18 +123,13 @@ module Hutch
       @channel = open_channel
     end
 
-    def install_channel_recovery!(ch)
-      ch.on_error do |channel, close|
-        next unless close.delivery_ack_timeout?
-
-        begin
-          channel.reopen
-          connection.recover_channel_topology(channel)
-          logger.warn 'recovered consumer channel after a delivery acknowledgement timeout'
-        rescue => ex
-          logger.error "channel recovery failed: #{ex.class}: #{ex.message}"
-        end
-      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)
@@ -193,6 +189,10 @@ module Hutch
       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]/, "")
@@ -205,7 +205,7 @@ module Hutch
 
       filtered = api_client.bindings.
         reject { |b| b['destination'] == b['routing_key'] }.
-        select { |b| b['source'] == @config[:mq_exchange] && b['vhost'] == @config[:mq_vhost] }
+        select { |b| b['source'] == @config[:mq_exchange] && b['vhost'] == vhost }
 
       filtered.each do |binding|
         results[binding['destination']] << binding['routing_key']
@@ -244,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)
@@ -288,6 +285,27 @@ 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
 
@@ -299,7 +317,7 @@ module Hutch
         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
 
@@ -309,7 +327,7 @@ 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]
@@ -343,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
@@ -356,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

@@ -36,12 +36,9 @@ module Hutch
       set_up_code_paths!
 
       # 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
+      # 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?(Raven)
-        Hutch::Config[:error_handlers] << Hutch::ErrorHandlers::SentryRaven.new
-      end
       if defined?(Sentry)
         Hutch::Config[:error_handlers] << Hutch::ErrorHandlers::Sentry.new
       end

data/lib/hutch/config.rb

@@ -57,7 +57,7 @@ module Hutch
 
     # 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
@@ -78,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.
@@ -104,7 +104,7 @@ module Hutch
     # Bunny's reconnect interval
     number_setting :network_recovery_interval, 1
 
-    # FIXME: DOCUMENT THIS
+    # 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

data/lib/hutch/consumer.rb

@@ -14,12 +14,12 @@ module Hutch
 
     def reject!
       @message_rejected = true
-      broker.reject(delivery_info.delivery_tag)
+      broker.reject(delivery_info.delivery_tag, channel: delivery_info.channel)
     end
 
     def requeue!
       @message_rejected = true
-      broker.requeue(delivery_info.delivery_tag)
+      broker.requeue(delivery_info.delivery_tag, channel: delivery_info.channel)
     end
 
     def message_rejected?
@@ -80,7 +80,7 @@ module Hutch
         @arguments = arguments
       end
 
-      # Congfiures queue options that will be passed when declaring the queue.
+      # Configures queue options that will be passed when declaring the queue.
       def queue_options(options = {})
         @queue_options = options
       end

data/lib/hutch/error_handlers.rb

@@ -2,7 +2,6 @@ module Hutch
   module ErrorHandlers
     autoload :Logger,      'hutch/error_handlers/logger'
     autoload :Sentry,      'hutch/error_handlers/sentry'
-    autoload :SentryRaven, 'hutch/error_handlers/sentry_raven'
     autoload :Honeybadger, 'hutch/error_handlers/honeybadger'
     autoload :Airbrake,    'hutch/error_handlers/airbrake'
     autoload :Rollbar,     'hutch/error_handlers/rollbar'