hutch 0.27.0 → 1.1.1

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,18 +29,47 @@ 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
 
+      # Congfiures 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 +87,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/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.1'.freeze
 end

data/lib/hutch/worker.rb

@@ -47,7 +47,7 @@ module Hutch
     def setup_queue(consumer)
       logger.info "setting up queue: #{consumer.get_queue_name}"
 
-      queue = @broker.queue(consumer.get_queue_name, consumer.get_arguments)
+      queue = @broker.queue(consumer.get_queue_name, consumer.get_options)
       @broker.bind_queue(queue, consumer.routing_keys)
 
       queue.subscribe(consumer_tag: unique_consumer_tag, manual_ack: true) do |*args|

data/spec/hutch/broker_spec.rb

@@ -262,7 +262,7 @@ describe Hutch::Broker do
         args.first == ''
         args.last == arguments
       end
-      broker.queue('test', arguments)
+      broker.queue('test', arguments: arguments)
     end
   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

data/spec/hutch/worker_spec.rb

@@ -4,7 +4,7 @@ require 'hutch/worker'
 describe Hutch::Worker do
   let(:consumer) { double('Consumer', routing_keys: %w( a b c ),
                           get_queue_name: 'consumer', get_arguments: {},
-                          get_serializer: nil) }
+                          get_options: {}, get_serializer: nil) }
   let(:consumers) { [consumer, double('Consumer')] }
   let(:broker) { Hutch::Broker.new }
   let(:setup_procs) { Array.new(2) { Proc.new {} } }
@@ -35,7 +35,7 @@ describe Hutch::Worker do
     before { allow(broker).to receive_messages(queue: queue, bind_queue: nil) }
 
     it 'creates a queue' do
-      expect(broker).to receive(:queue).with(consumer.get_queue_name, consumer.get_arguments).and_return(queue)
+      expect(broker).to receive(:queue).with(consumer.get_queue_name, consumer.get_options).and_return(queue)
       worker.setup_queue(consumer)
     end