hutch 0.27.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07e4ec8d85eefed7b25ae9bb43fb3c0ff8ffe0a4f24526b986686906aaa0f5cc
-  data.tar.gz: 94062cdf67c00e9224d3fee9be1fa294ba0e234f8400ec4efc640eaecc07a2df
+  metadata.gz: 74721c392b797963bf268ff65d638b888e11d43307446ed63bd3de14e36aa97e
+  data.tar.gz: 1ddb6053bd164c0332650169415ae9a20daa9724039be7765cc90aade1e0f304
 SHA512:
-  metadata.gz: e5a9ef9a749741aee734246701cde0a99f1c36f02e730eb1e888d2a125dba6e4ed9f9cdf945656ebbf8dcd118775c4717110c4d542b6547df84119baeb29f0a4
-  data.tar.gz: 8a929dafd7c168256da9c349e4bf60a052456f2d34db4e717e3c46a08e461dac60f95ea6903a76a54bb934fbbcabb62a1c2e24b662469d3e5afd9e459a165b2c
+  metadata.gz: e690481212eeca9499f491b34c39e9f8e4f883f617063a5123bf1471e87b7f7251c52e0c92b103fe73dfa8db1859ad5feca76b6f0694ff68554191e66621f209
+  data.tar.gz: 043c203877a230f2d50c023a005ce84c7a7fc764c2b6ce3d452ab8aa143fa4175e4ba4bd54a4e2e611839360b2ec292d28c03ec338c92bbaa3b84e34b8a644f0

data/.travis.yml

@@ -1,3 +1,6 @@
+dist: bionic
+sudo: required
+
 language: ruby
 cache: bundler
 before_install:
@@ -5,18 +8,16 @@ before_install:
 before_script:
   - "./bin/ci/install_on_debian.sh"
   - until sudo lsof -i:5672; do echo "Waiting for RabbitMQ to start..."; sleep 1; done
+  - "./bin/ci/before_build.sh"
 matrix:
   include:
-    - rvm: "2.6.4"
-    - rvm: "2.5.6"
-    - rvm: "2.4.7"
-    - rvm: "2.3.8"
-    - rvm: "jruby-9.2.8.0"
+    - rvm: "3.0.0"  
+    - rvm: "2.7.1"
+    - rvm: "2.6.6"
+    - rvm: "2.5.8"
+    - rvm: "jruby-9.2.19.0"
+      name: "Latest JRuby"
     - rvm: "ruby-head"
   allow_failures:
-    rvm:
-      - "jruby-9.2.8.0"
-      - ruby-head
-
-services:
-  - rabbitmq
+    - name: "Latest JRuby"
+    - rvm: ruby-head

data/CHANGELOG.md

@@ -1,7 +1,127 @@
-## 0.28.0 (under development)
+## 1.1.0 (July 26th, 2021)
 
-No chages yet.
+### Bugsnag Error Handler
 
+Contributed by @ivanhuang1.
+
+GitHub issue: [#362](https://github.com/ruby-amqp/hutch/pull/362)
+
+### Updated Sentry Error Handler
+
+Contributed by Karol @Azdaroth Galanciak.
+
+GitHub issue: [#363](https://github.com/ruby-amqp/hutch/pull/363)
+
+
+### Type Casting for Values Set Using Hutch::Config.set
+
+Values set with `Hutch::Config.set` now have expected setting type casting
+applied to them.
+
+Contributed by Karol @Azdaroth Galanciak.
+
+GitHub issue: [#358](https://github.com/ruby-amqp/hutch/pull/358)
+
+
+## 1.0.0 (April 8th, 2020)
+
+Hutch has been around for several years. It is time to ship a 1.0. With it we try to correct
+a few of overly opinionated decisions from recent releases. This means this release
+contains potentially breaking changes.
+
+### Breaking Changes
+
+ * Hutch will no longer configure any queue type (such as [quorum queues](https://www.rabbitmq.com/quorum-queues.html))
+   or queue mode (used by classic [lazy queues](https://www.rabbitmq.com/lazy-queues.html))
+   by default as that can be breaking change for existing Hutch and RabbitMQ installations due to the
+   [property equivalence requirement](https://www.rabbitmq.com/queues.html#property-equivalence) in AMQP 0-9-1.
+
+   This means **some defaults introduced in `0.28.0` ([gocardless/hutch#341](https://github.com/gocardless/hutch/pull/341)) were reverted**.
+   The user has to opt in to configure the queue type and mode and other [optional arguments](https://www.rabbitmq.com/queues.html#optional-arguments) they need to use.
+   Most optional arguments can be set via [policies](https://www.rabbitmq.com/parameters.html#policies) which is always the recommended approach. 
+   Queue type, unfortunately, is not one of them as different queue types have completely different
+   implementation details, on disk data formats and so on.
+
+   To use a quorum queue, use the `quorum_queue` consumer DSL method:
+
+   ``` ruby
+   class ConsumerUsingQuorumQueue
+      include Hutch::Consumer
+      consume 'hutch.test1'
+      # when in doubt, prefer using a policy to this DSL
+      # https://www.rabbitmq.com/parameters.html#policies
+      arguments 'x-key': :value
+        
+      quorum_queue
+   end
+   ```
+
+   To use a classic lazy queue, use the `lazy_queue` consumer DSL method:
+
+   ``` ruby
+   class ConsumerUsingLazyQueue
+     include Hutch::Consumer
+     consume 'hutch.test1'
+     # when in doubt, prefer using a policy to this DSL
+      # https://www.rabbitmq.com/parameters.html#policies
+      arguments 'x-key': :value
+     
+     lazy_queue
+     classic_queue
+   end
+   ```
+
+   By default Hutch will not configure any `x-queue-type` or `x-queue-mode` optional arguments
+   which is identical to RabbitMQ defaults (a regular classic queue).
+
+   Note that as of RabbitMQ 3.8.2, an omitted `x-queue-type` is [considered to be identical](https://github.com/rabbitmq/rabbitmq-common/issues/341)
+   to `x-queue-type` set to `classic` by RabbitMQ server.
+
+
+   #### Enhancements
+
+    * Exchange type is now configurable via the `mq_exchange_type` config setting. Supported exchanges must be
+      compatible with topic exchanges (e.g. wrap it). Default value is `topic`.
+
+      This feature is limited to topic and delayed message exchange plugins and is mostly
+      useful for forward compatibility.
+
+      Contributed by Michael Bumann.
+
+      GitHub issue: [gocardless/hutch#349](https://github.com/gocardless/hutch/pull/349)
+
+
+## 0.28.0 (March 17, 2020)
+
+### Enhancements
+
+  * Add lazy and quorum options for queues.
+
+    GitHub issue: [gocardless/hutch#341](https://github.com/gocardless/hutch/pull/341)
+
+    Contributed by: Arthur Del Esposte
+
+  * Log level in the message publisher switched to DEBUG.
+
+    GitHub issue: [gocardless/hutch#343](https://github.com/gocardless/hutch/pull/343)
+
+    Contributed by: Codruț Constantin Gușoi
+
+### Documentation
+
+  * Add zeitwerk note to README.
+
+    GitHub issue: [gocardless/hutch#342](https://github.com/gocardless/hutch/pull/342)
+
+    Contributed by: Paolo Zaccagnini
+
+### CI
+
+  * Use jruby-9.2.9.0
+
+    GitHub issue: [gocardless/hutch#336](https://github.com/gocardless/hutch/pull/336)
+
+    Contributed by: Olle Jonsson
 
 ## 0.27.0 (September 9th, 2019)
 

data/Gemfile

@@ -20,11 +20,14 @@ group :development, :test do
   gem "simplecov", "~> 0.12"
 
   gem "sentry-raven"
+  gem "sentry-ruby"
   gem "honeybadger"
   gem "coveralls", "~> 0.8.15", require: false
   gem "newrelic_rpm"
-  gem "airbrake", "~> 9.0"
+  gem "ddtrace"
+  gem "airbrake", "~> 10.0"
   gem "rollbar"
+  gem "bugsnag"
 end
 
 group :development, :darwin do

data/LICENSE

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

data/README.md

@@ -39,7 +39,7 @@ gem install hutch
 
 ## Requirements
 
-- Hutch requires Ruby 2.3+ or JRuby 9K.
+- Hutch requires Ruby 2.4+ or JRuby 9K.
 - Hutch requires RabbitMQ 3.3 or later.
 
 ## Overview
@@ -59,8 +59,8 @@ Hutch uses [Bunny](http://rubybunny.info) or [March Hare](http://rubymarchhare.i
 ### Project Maturity
 
 Hutch is a mature project that was originally extracted from production systems
-at [GoCardless](https://gocardless.com) in 2013 and is now maintained by a large
-group of contributors.
+at [GoCardless](https://gocardless.com) in 2013 and is now maintained by its contributors
+and users.
 
 ## Consumers
 
@@ -109,6 +109,28 @@ class FailedPaymentConsumer
 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).
+The `initial_group_size`
+[argument](https://www.rabbitmq.com/quorum-queues.html#replication-factor) is
+optional.
+
+```ruby
+class FailedPaymentConsumer
+  include Hutch::Consumer
+  consume 'gc.ps.payment.failed'
+  queue_name 'failed_payments'
+  lazy_queue
+  quorum_queue initial_group_size: 3
+
+  def process(message)
+    mark_payment_as_failed(message[:id])
+  end
+end
+```
+
 You can also set custom arguments per consumer. This example declares a consumer with
 a maximum length of 10 messages:
 
@@ -166,6 +188,12 @@ This will enable NewRelic custom instrumentation:
 Hutch::Config.set(:tracer, Hutch::Tracers::NewRelic)
 ```
 
+And this will enable Datadog custom instrumentation:
+
+```ruby
+Hutch::Config.set(:tracer, Hutch::Tracers::Datadog)
+```
+
 Batteries included!
 
 ## Running Hutch
@@ -219,13 +247,55 @@ directory of a Rails app, or pass the path to a Rails app in with the
 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
+
+```ruby
+::Zeitwerk::Loader.eager_load_all
+```
+
+or with something more specific like
+
+```ruby
+autoloader = Rails.autoloaders.main
+
+Dir.glob(File.join('app/consumers', '*_consumer.rb')).each do |consumer|
+  autoloader.preload(consumer)
+end
+```
+
+### Consumer Groups
+
+It is possible to load only a subset of consumers. This is done by defining a consumer
+group under the `consumer_groups` configuration key:
+
+``` yaml
+consumer_groups:
+  payments:
+    - DepositConsumer
+    - CashoutConsumer
+  notification:
+    - EmailNotificationConsumer
+```
+
+To only load a group of consumers, use the `--only-group` option:
+
+``` shell
+hutch --only-group=payments --config=/path/to/hutch.yaml
+```
+
+### Loading Consumers Manually (One-by-One)
+
 To require files that define consumers manually, simply pass each file as an
 option to `--require`. Hutch will automatically detect whether you've provided
 a Rails app or a standard file, and take the appropriate behaviour:
 
 ```bash
-$ hutch --require path/to/rails-app  # loads a rails app
-$ hutch --require path/to/file.rb    # loads a ruby file
+# loads a rails app
+hutch --require path/to/rails-app
+# loads a ruby file
+hutch --require path/to/file.rb
 ```
 
 ### Stopping Hutch
@@ -344,6 +414,7 @@ Known configuration parameters are:
  * `automatically_recover`: Bunny's enable/disable network recovery (default: `true`)
  * `network_recovery_interval`: Bunny's reconnect interval (default: `1`)
  * `tracer`: tracer to use to track message processing
+ * `namespace`: A namespace string to help group your queues (default: `nil`)
 
 ### Environment variables
 
@@ -402,6 +473,13 @@ Generate with
       <td><tt>HUTCH_MQ_EXCHANGE</tt></td>
       <td><p>RabbitMQ Exchange to use for publishing</p></td>
     </tr>
+    <tr>
+      <td><tt>mq_exchange_type</tt></td>
+      <td>topic</td>
+      <td>String</td>
+      <td><tt>HUTCH_MQ_EXCHANGE_TYPE</tt></td>
+      <td><p>RabbitMQ Exchange type to use for publishing</p></td>
+    </tr>
     <tr>
       <td><tt>mq_vhost</tt></td>
       <td>/</td>
@@ -584,5 +662,19 @@ Generate with
       <td><tt>HUTCH_CONSUMER_TAG_PREFIX</tt></td>
       <td><p>Prefix displayed on the consumers tags.</p></td>
     </tr>
+    <tr>
+      <td><tt>namespace</tt></td>
+      <td>nil</td>
+      <td>String</td>
+      <td><tt>HUTCH_NAMESPACE</tt></td>
+      <td><p>A namespace to help group your queues</p></td>
+    </tr>
+    <tr>
+      <td><tt>group</tt></td>
+      <td>''</td>
+      <td>String</td>
+      <td><tt>HUTCH_GROUP</tt></td>
+      <td></td>
+    </tr>
   </tbody>
 </table>

data/bin/ci/before_build.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env sh
+
+CTL=${BUNNY_RABBITMQCTL:-"sudo rabbitmqctl"}
+PLUGINS=${BUNNY_RABBITMQ_PLUGINS:-"sudo rabbitmq-plugins"}
+
+echo "Will use rabbitmqctl at ${CTL}"
+echo "Will use rabbitmq-plugins at ${PLUGINS}"
+
+$PLUGINS enable rabbitmq_management
+
+sleep 3
+
+# guest:guest has full access to /
+$CTL add_vhost /
+$CTL add_user guest guest
+$CTL set_permissions -p / guest ".*" ".*" ".*"
+
+# Reduce retention policy for faster publishing of stats
+$CTL eval 'supervisor2:terminate_child(rabbit_mgmt_sup_sup, rabbit_mgmt_sup), application:set_env(rabbitmq_management,       sample_retention_policies, [{global, [{605, 1}]}, {basic, [{605, 1}]}, {detailed, [{10, 1}]}]), rabbit_mgmt_sup_sup:start_child().' || true
+$CTL eval  'supervisor2:terminate_child(rabbit_mgmt_agent_sup_sup, rabbit_mgmt_agent_sup), application:set_env(rabbitmq_management_agent, sample_retention_policies, [{global, [{605, 1}]}, {basic, [{605, 1}]}, {detailed, [{10, 1}]}]), rabbit_mgmt_agent_sup_sup:start_child().' || true

data/bin/ci/install_on_debian.sh

@@ -1,17 +1,46 @@
 #!/bin/sh
 
-sudo apt-get install -y wget
-wget -O - "https://github.com/rabbitmq/signing-keys/releases/download/2.0/rabbitmq-release-signing-key.asc" | sudo apt-key add -
+sudo apt-get install curl gnupg debian-keyring debian-archive-keyring apt-transport-https -y
 
-sudo tee /etc/apt/sources.list.d/bintray.rabbitmq.list <<EOF
-deb https://dl.bintray.com/rabbitmq-erlang/debian xenial erlang
-deb https://dl.bintray.com/rabbitmq/debian xenial main
+## Team RabbitMQ's main signing key
+sudo apt-key adv --keyserver "hkps://keys.openpgp.org" --recv-keys "0x0A9AF2115F4687BD29803A206B73A36E6026DFCA"
+## Launchpad PPA that provides modern Erlang releases
+sudo apt-key adv --keyserver "keyserver.ubuntu.com" --recv-keys "F77F1EDA57EBB1CC"
+## PackageCloud RabbitMQ repository
+sudo apt-key adv --keyserver "keyserver.ubuntu.com" --recv-keys "F6609E60DC62814E"
+
+## Add apt repositories maintained by Team RabbitMQ
+sudo tee /etc/apt/sources.list.d/rabbitmq.list <<EOF
+## Provides modern Erlang/OTP releases
+##
+## "bionic" as distribution name should work for any reasonably recent Ubuntu or Debian release.
+## See the release to distribution mapping table in RabbitMQ doc guides to learn more.
+deb http://ppa.launchpad.net/rabbitmq/rabbitmq-erlang/ubuntu bionic main
+deb-src http://ppa.launchpad.net/rabbitmq/rabbitmq-erlang/ubuntu bionic main
+
+## Provides RabbitMQ
+##
+## "bionic" as distribution name should work for any reasonably recent Ubuntu or Debian release.
+## See the release to distribution mapping table in RabbitMQ doc guides to learn more.
+deb https://packagecloud.io/rabbitmq/rabbitmq-server/ubuntu/ bionic main
+deb-src https://packagecloud.io/rabbitmq/rabbitmq-server/ubuntu/ bionic main
 EOF
 
+## Update package indices
 sudo apt-get update -y
-sudo apt-get upgrade -y
-sudo apt-get install -y rabbitmq-server
+
+## Install Erlang packages
+sudo apt-get install -y erlang-base \
+                        erlang-asn1 erlang-crypto erlang-eldap erlang-ftp erlang-inets \
+                        erlang-mnesia erlang-os-mon erlang-parsetools erlang-public-key \
+                        erlang-runtime-tools erlang-snmp erlang-ssl \
+                        erlang-syntax-tools erlang-tftp erlang-tools erlang-xmerl
+
+## Install rabbitmq-server and its dependencies
+sudo apt-get install rabbitmq-server -y --fix-missing
 
 sudo service rabbitmq-server start
 
+sudo rabbitmqctl await_startup --timeout 120
+
 until sudo lsof -i:5672; do echo "Waiting for RabbitMQ to start..."; sleep 1; done

data/hutch.gemspec

@@ -6,10 +6,10 @@ Gem::Specification.new do |gem|
     gem.add_runtime_dependency 'march_hare', '>= 3.0.0'
   else
     gem.platform = Gem::Platform::RUBY
-    gem.add_runtime_dependency 'bunny', '>= 2.13', '< 2.15'
+    gem.add_runtime_dependency 'bunny', '>= 2.16', '< 3.0'
   end
   gem.add_runtime_dependency 'carrot-top', '~> 0.0.7'
-  gem.add_runtime_dependency 'multi_json', '~> 1.12'
+  gem.add_runtime_dependency 'multi_json', '~> 1.14'
   gem.add_runtime_dependency 'activesupport', '>= 4.2', '< 7'
 
   gem.name = 'hutch'

data/lib/hutch/broker.rb

@@ -122,11 +122,12 @@ module Hutch
 
     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)
+        Bunny::Exchange.new(ch, exchange_type, exchange_name, exchange_options)
       end
     end
 
@@ -181,12 +182,15 @@ module Hutch
     # 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'] == @config[:mq_vhost] }
+
+      filtered.each do |binding|
         results[binding['destination']] << binding['routing_key']
       end
+
       results
     end
 
@@ -194,8 +198,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)

data/lib/hutch/cli.rb

@@ -33,6 +33,23 @@ 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 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::SentryRaven.new
+      end
+      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)
@@ -51,16 +68,6 @@ module Hutch
           $LOAD_PATH.pop
         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)

data/lib/hutch/config.rb

@@ -49,6 +49,9 @@ 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, '/'
 
@@ -142,6 +145,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
@@ -190,14 +196,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
 
@@ -232,7 +231,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
@@ -269,6 +268,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

@@ -29,14 +29,38 @@ 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.
+      # 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
@@ -58,7 +82,13 @@ 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
 
       # 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/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", 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/sentry_raven.rb

@@ -0,0 +1,31 @@
+require 'hutch/logging'
+require 'raven'
+require 'hutch/error_handlers/base'
+
+module Hutch
+  module ErrorHandlers
+    class SentryRaven < 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 })
+      end
+
+      def handle_setup_exception(ex)
+        logger.error "Logging setup exception to Sentry"
+        logger.error "#{ex.class} - #{ex.message}"
+        Raven.capture_exception(ex)
+      end
+
+    end
+  end
+end

data/lib/hutch/error_handlers.rb

@@ -2,8 +2,10 @@ 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'
+    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

@@ -6,7 +6,7 @@ module Hutch
     class JSON
 
       def self.encode(payload)
-        ::JSON.dump(payload)
+        ::MultiJson.dump(payload)
       end
 
       def self.decode(payload)

data/lib/hutch/tracers/datadog.rb

@@ -0,0 +1,17 @@
+require 'ddtrace'
+
+module Hutch
+  module Tracers
+    class Datadog
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def handle(message)
+        ::Datadog.tracer.trace(@klass.class.name, service: 'hutch', span_type: 'rabbitmq') do
+          @klass.process(message)
+        end
+      end
+    end
+  end
+end

data/lib/hutch/tracers.rb

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

data/lib/hutch/version.rb

@@ -1,3 +1,3 @@
 module Hutch
-  VERSION = '0.27.0'.freeze
+  VERSION = '1.1.0'.freeze
 end

data/spec/hutch/config_spec.rb

@@ -49,6 +49,44 @@ describe Hutch::Config do
       context 'sets value in user config hash' do
         it { is_expected.to eq(new_value) }
       end
+
+      context 'type casting' do
+        context 'number attributes' do
+          before  { Hutch::Config.set(:heartbeat, new_value) }
+          subject(:value) { Hutch::Config.user_config[:heartbeat] }
+
+          let(:new_value) { "0" }
+
+
+          specify 'casts values to integers' do
+            expect(value).to eq 0
+          end
+        end
+      end
+
+      context 'boolean attributes' do
+        before  { Hutch::Config.set(:autoload_rails, new_value) }
+        subject(:value) { Hutch::Config.user_config[:autoload_rails] }
+
+        let(:new_value) { "t" }
+
+
+        specify 'casts values to booleans' do
+          expect(value).to eq true
+        end
+      end
+
+      context 'string attributes' do
+        before  { Hutch::Config.set(:mq_exchange_type, new_value) }
+        subject(:value) { Hutch::Config.user_config[:mq_exchange_type] }
+
+        let(:new_value) { 1 }
+
+
+        specify 'does not perform any typecasting' do
+          expect(value).to eq new_value
+        end
+      end
     end
 
     context 'for invalid attributes' do

data/spec/hutch/consumer_spec.rb

@@ -28,6 +28,32 @@ describe Hutch::Consumer do
     ComplexConsumer
   end
 
+  let(:consumer_using_quorum_queue) do
+    unless defined? ConsumerUsingQuorumQueue
+      class ConsumerUsingQuorumQueue
+        include Hutch::Consumer
+        consume 'hutch.test1'
+        arguments foo: :bar
+        
+        quorum_queue
+      end
+    end
+    ConsumerUsingQuorumQueue
+  end
+
+  let(:consumer_using_classic_queue) do
+    unless defined? ConsumerUsingLazyQueue
+      class ConsumerUsingLazyQueue
+        include Hutch::Consumer
+        consume 'hutch.test1'
+        arguments foo: :bar
+        lazy_queue
+        classic_queue
+      end
+    end
+    ConsumerUsingLazyQueue
+  end
+
   describe 'module inclusion' do
     it 'registers the class as a consumer' do
       expect(Hutch).to receive(:register_consumer) do |klass|
@@ -71,6 +97,43 @@ describe Hutch::Consumer do
     end
   end
 
+  describe 'default queue mode' do
+    it 'does not specify any mode by default' do
+      expect(simple_consumer.queue_mode).to eq(nil)
+      expect(simple_consumer.queue_type).to eq(nil)
+    end
+  end
+
+  describe '.lazy_queue' do
+    context 'when queue mode has been set explicitly to lazy' do
+      it 'sets queue mode to lazy' do
+        expect(consumer_using_classic_queue.queue_mode).to eq('lazy')
+      end
+    end
+  end
+
+  describe '.classic_queue' do
+    context 'when queue type has been set explicitly to classic' do
+      it 'sets queue type to classic' do
+        expect(consumer_using_classic_queue.queue_type).to eq('classic')
+      end
+    end
+  end
+
+  describe '.quorum_queue' do
+    context 'when queue type has been set explicitly to quorum' do
+      it 'sets queue type to quorum' do
+        expect(consumer_using_quorum_queue.queue_type).to eq('quorum')
+      end
+
+      it 'accepts initial group size as an option' do
+        consumer = simple_consumer
+        expect { consumer.quorum_queue(initial_group_size: 3) }
+          .to change { consumer.initial_group_size }.to(3)
+      end
+    end
+  end
+
   describe '.arguments' do
     let(:args) { { foo: :bar} }
 
@@ -82,15 +145,30 @@ describe Hutch::Consumer do
   end
 
   describe '.get_arguments' do
-
     context 'when defined' do
-      it { expect(complex_consumer.get_arguments).to eq(foo: :bar) }
+      it { expect(complex_consumer.get_arguments).to include(foo: :bar) }
     end
 
-    context 'when not defined' do
-      it { expect(simple_consumer.get_arguments).to eq({}) }
+    context 'when queue is lazy' do
+      it 'has the x-queue-mode argument set to lazy' do
+        expect(consumer_using_classic_queue.get_arguments['x-queue-mode'])
+          .to eq('lazy')
+      end
     end
 
+    context "when queue's type is quorum" do
+      let(:arguments) { consumer_using_quorum_queue.get_arguments }
+      it 'has the x-queue-type argument set to quorum' do
+        expect(arguments['x-queue-type']).to eq('quorum')
+        expect(arguments).to_not have_key('x-quorum-initial-group-size')
+      end
+
+      it 'has the x-quorum-initial-group-size argument set to quorum' do
+        consumer_using_quorum_queue.quorum_queue(initial_group_size: 5)
+        expect(arguments['x-queue-type']).to eq('quorum')
+        expect(arguments['x-quorum-initial-group-size']).to eq(5)
+      end
+    end
   end
 
   describe '.get_queue_name' do

data/spec/hutch/error_handlers/bugsnag_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Hutch::ErrorHandlers::Bugsnag do
+  let(:error_handler) { described_class.new }
+
+  before do
+    Bugsnag.configure do |bugsnag|
+      bugsnag.api_key = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+    end
+  end
+
+  describe "#handle" do
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Bugsnag" do
+      message_id = "1"
+      properties = OpenStruct.new(message_id: message_id)
+      payload = "{}"
+      consumer = double
+      ex = error
+      message = {
+        payload: payload,
+        consumer: consumer
+      }
+
+      expect(::Bugsnag).to receive(:notify).with(ex).and_call_original
+      expect_any_instance_of(::Bugsnag::Report).to receive(:add_tab).with(:hutch, message)
+      error_handler.handle(properties, payload, consumer, ex)
+    end
+  end
+
+  describe "#handle_setup_exception" do
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Bugsnag" do
+      ex = error
+      expect(::Bugsnag).to receive(:notify).with(ex)
+      error_handler.handle_setup_exception(ex)
+    end
+  end
+end

data/spec/hutch/error_handlers/sentry_raven_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Hutch::ErrorHandlers::SentryRaven do
+  let(:error_handler) { Hutch::ErrorHandlers::SentryRaven.new }
+
+  describe '#handle' do
+    let(:properties) { OpenStruct.new(message_id: "1") }
+    let(:payload) { "{}" }
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Sentry" do
+      expect(Raven).to receive(:capture_exception).with(error, extra: { payload: payload })
+      error_handler.handle(properties, payload, double, error)
+    end
+  end
+
+  describe '#handle_setup_exception' do
+    let(:error) do
+      begin
+        raise "Stuff went wrong during setup"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Sentry" do
+      expect(Raven).to receive(:capture_exception).with(error)
+      error_handler.handle_setup_exception(error)
+    end
+  end
+end

data/spec/hutch/error_handlers/sentry_spec.rb

@@ -15,7 +15,8 @@ describe Hutch::ErrorHandlers::Sentry do
     end
 
     it "logs the error to Sentry" do
-      expect(Raven).to receive(:capture_exception).with(error, extra: { payload: payload })
+      expect(::Sentry).to receive(:capture_exception).with(error).and_call_original
+
       error_handler.handle(properties, payload, double, error)
     end
   end
@@ -30,7 +31,8 @@ describe Hutch::ErrorHandlers::Sentry do
     end
 
     it "logs the error to Sentry" do
-      expect(Raven).to receive(:capture_exception).with(error)
+      expect(::Sentry).to receive(:capture_exception).with(error).and_call_original
+
       error_handler.handle_setup_exception(error)
     end
   end

data/spec/hutch/tracers/datadog_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe Hutch::Tracers::Datadog do
+  describe "#handle" do
+    subject(:handle) { tracer.handle(message) }
+
+    let(:tracer) { described_class.new(klass) }
+    let(:klass)  do
+      Class.new do
+        attr_reader :message
+
+        def initialize
+          @message = nil
+        end
+
+        def class
+          OpenStruct.new(name: 'ClassName')
+        end
+
+        def process(message)
+          @message = message
+        end
+      end.new
+    end
+    let(:message) { double(:message) }
+
+    before do
+      allow(Datadog.tracer).to receive(:trace).and_call_original
+    end
+
+    it 'uses Datadog tracer' do
+      handle
+
+      expect(Datadog.tracer).to have_received(:trace).with('ClassName',
+        hash_including(service: 'hutch', span_type: 'rabbitmq'))
+    end
+
+    it 'processes the message' do
+      expect {
+        handle
+      }.to change { klass.message }.from(nil).to(message)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hutch
 version: !ruby/object:Gem::Version
-  version: 0.27.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Harry Marr
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-09-09 00:00:00.000000000 Z
+date: 2021-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '2.16'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.15'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '2.16'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.15'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: carrot-top
   requirement: !ruby/object:Gem::Requirement
@@ -50,14 +50,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.14'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -97,6 +97,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/ci/before_build.sh
 - bin/ci/install_on_debian.sh
 - bin/hutch
 - examples/consumer.rb
@@ -115,10 +116,12 @@ files:
 - lib/hutch/error_handlers.rb
 - lib/hutch/error_handlers/airbrake.rb
 - lib/hutch/error_handlers/base.rb
+- lib/hutch/error_handlers/bugsnag.rb
 - lib/hutch/error_handlers/honeybadger.rb
 - lib/hutch/error_handlers/logger.rb
 - lib/hutch/error_handlers/rollbar.rb
 - lib/hutch/error_handlers/sentry.rb
+- lib/hutch/error_handlers/sentry_raven.rb
 - lib/hutch/exceptions.rb
 - lib/hutch/logging.rb
 - lib/hutch/message.rb
@@ -126,6 +129,7 @@ files:
 - lib/hutch/serializers/identity.rb
 - lib/hutch/serializers/json.rb
 - lib/hutch/tracers.rb
+- lib/hutch/tracers/datadog.rb
 - lib/hutch/tracers/newrelic.rb
 - lib/hutch/tracers/null_tracer.rb
 - lib/hutch/version.rb
@@ -138,13 +142,16 @@ files:
 - spec/hutch/config_spec.rb
 - spec/hutch/consumer_spec.rb
 - spec/hutch/error_handlers/airbrake_spec.rb
+- spec/hutch/error_handlers/bugsnag_spec.rb
 - spec/hutch/error_handlers/honeybadger_spec.rb
 - spec/hutch/error_handlers/logger_spec.rb
 - spec/hutch/error_handlers/rollbar_spec.rb
+- spec/hutch/error_handlers/sentry_raven_spec.rb
 - spec/hutch/error_handlers/sentry_spec.rb
 - spec/hutch/logger_spec.rb
 - spec/hutch/message_spec.rb
 - spec/hutch/serializers/json_spec.rb
+- spec/hutch/tracers/datadog_spec.rb
 - spec/hutch/waiter_spec.rb
 - spec/hutch/worker_spec.rb
 - spec/hutch_spec.rb
@@ -162,7 +169,7 @@ homepage: https://github.com/gocardless/hutch
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -177,8 +184,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Easy inter-service communication using RabbitMQ.
 test_files:
@@ -187,13 +194,16 @@ test_files:
 - spec/hutch/config_spec.rb
 - spec/hutch/consumer_spec.rb
 - spec/hutch/error_handlers/airbrake_spec.rb
+- spec/hutch/error_handlers/bugsnag_spec.rb
 - spec/hutch/error_handlers/honeybadger_spec.rb
 - spec/hutch/error_handlers/logger_spec.rb
 - spec/hutch/error_handlers/rollbar_spec.rb
+- spec/hutch/error_handlers/sentry_raven_spec.rb
 - spec/hutch/error_handlers/sentry_spec.rb
 - spec/hutch/logger_spec.rb
 - spec/hutch/message_spec.rb
 - spec/hutch/serializers/json_spec.rb
+- spec/hutch/tracers/datadog_spec.rb
 - spec/hutch/waiter_spec.rb
 - spec/hutch/worker_spec.rb
 - spec/hutch_spec.rb