rabbit_feed 2.4.4 → 3.0.0

data/lib/rabbit_feed/event_routing.rb

@@ -1,6 +1,5 @@
 module RabbitFeed
   class EventRouting
-
     class Event
       include ActiveModel::Validations
 
@@ -8,14 +7,14 @@ module RabbitFeed
       validates_presence_of :name, :action
       validate :action_arity
 
-      def initialize name, block
+      def initialize(name, block)
         @name   = name
         @action = block
 
         validate!
       end
 
-      def handle_event event
+      def handle_event(event)
         action.call event
       end
 
@@ -26,7 +25,7 @@ module RabbitFeed
       end
 
       def validate!
-        raise ConfigurationError.new "Bad event specification for #{name}: #{errors.messages}" if invalid?
+        raise ConfigurationError, "Bad event specification for #{name}: #{errors.messages}" if invalid?
       end
     end
 
@@ -36,18 +35,18 @@ module RabbitFeed
       attr_reader :named_events, :catch_all_event, :name
       validates_presence_of :name
 
-      def initialize name
+      def initialize(name)
         @name         = name
         @named_events = {}
 
         validate!
       end
 
-      def event name, &block
+      def event(name, &block)
         if name == :any
-          accept_any_event &block
+          accept_any_event(&block)
         else
-          accept_named_event name, &block
+          accept_named_event(name, &block)
         end
       end
 
@@ -57,34 +56,34 @@ module RabbitFeed
         end
       end
 
-      def handle_event event
+      def handle_event(event)
         event_rule = find_event event
         event_rule.handle_event event
       end
 
-      def handles_event? event
+      def handles_event?(event)
         (find_event event).present?
       end
 
       private
 
       def validate!
-        raise ConfigurationError.new "Bad application specification for #{name}: #{errors.messages}" if invalid?
+        raise ConfigurationError, "Bad application specification for #{name}: #{errors.messages}" if invalid?
       end
 
-      def accept_named_event name, &block
-        raise ConfigurationError.new "Routing has already been defined for the event with name: #{name} in application: #{self.name}" if (named_events.has_key? name)
+      def accept_named_event(name, &block)
+        raise ConfigurationError, "Routing has already been defined for the event with name: #{name} in application: #{self.name}" if named_events.key? name
         event = (Event.new name, block)
         named_events[event.name] = event
       end
 
-      def accept_any_event &block
-        raise ConfigurationError.new "Routing has already been defined for the event catch-all: :any in application: #{name}" if catch_all_event.present?
+      def accept_any_event(&block)
+        raise ConfigurationError, "Routing has already been defined for the event catch-all: :any in application: #{name}" if catch_all_event.present?
         event = (Event.new '*', block)
         @catch_all_event = event
       end
 
-      def find_event event
+      def find_event(event)
         [named_events[event.name], catch_all_event].compact.first
       end
 
@@ -101,43 +100,43 @@ module RabbitFeed
       @named_applications = {}
     end
 
-    def accept_from name, &block
+    def accept_from(name, &block)
       if name == :any
-        accept_from_any_application &block
+        accept_from_any_application(&block)
       else
-        accept_from_named_application name, &block
+        accept_from_named_application(name, &block)
       end
     end
 
     def accepted_routes
-      routes = named_applications.values.map{|application| application.accepted_routes }.flatten
+      routes = named_applications.values.flat_map(&:accepted_routes)
       routes += catch_all_application.accepted_routes if catch_all_application.present?
       routes
     end
 
-    def handle_event event
+    def handle_event(event)
       application = find_application event
-      raise RoutingError.new "No routing defined for application with name: #{event.application} for events named: #{event.name}" unless application.present?
+      raise RoutingError, "No routing defined for application with name: #{event.application} for events named: #{event.name}" unless application.present?
       application.handle_event event
     end
 
     private
 
-    def accept_from_named_application name, &block
-      raise ConfigurationError.new "Routing has already been defined for the application with name: #{name}" if (named_applications.has_key? name)
+    def accept_from_named_application(name, &block)
+      raise ConfigurationError, "Routing has already been defined for the application with name: #{name}" if named_applications.key? name
       application = Application.new name
       application.instance_eval(&block)
       named_applications[application.name] = application
     end
 
-    def accept_from_any_application &block
-      raise ConfigurationError.new "Routing has already been defined for the application catch-all: :any" if catch_all_application.present?
+    def accept_from_any_application(&block)
+      raise ConfigurationError, 'Routing has already been defined for the application catch-all: :any' if catch_all_application.present?
       application = Application.new '*'
       application.instance_eval(&block)
       @catch_all_application = application
     end
 
-    def find_application event
+    def find_application(event)
       candidate_applications = [named_applications[event.application], catch_all_application].compact
       candidate_applications.detect do |application|
         application.handles_event? event

data/lib/rabbit_feed/json_log_formatter.rb

@@ -5,7 +5,7 @@ module RabbitFeed
         severity: severity,
         time: time.utc.iso8601(6),
         progname: progname,
-        message: msg,
+        message: msg
       }.to_json + "\n"
     end
   end

data/lib/rabbit_feed/producer.rb

@@ -4,21 +4,21 @@ module RabbitFeed
 
     attr_accessor :event_definitions
 
-    def publish_event name, payload
-      raise (Error.new 'Unable to publish event. No event definitions set.') unless event_definitions.present?
-      event_definition = event_definitions[name] or raise (Error.new "definition for event: #{name} not found")
-      timestamp        = Time.now.utc
-      metadata         = (metadata event_definition.version, name, timestamp)
-      event            = Event.new metadata, payload, event_definition.schema, event_definition.sensitive_fields
-      RabbitFeed.log.info {{ event: :publish_start, metadata: event.metadata }}
+    def publish_event(name, payload)
+      raise RabbitFeed::Error, 'Unable to publish event. No event definitions set.' unless event_definitions.present?
+      (event_definition = event_definitions[name]) || (raise RabbitFeed::Error, "definition for event: #{name} not found")
+      timestamp         = Time.now.utc
+      metadata          = (metadata event_definition.version, name, timestamp)
+      event             = Event.new metadata, payload, event_definition.schema, event_definition.sensitive_fields
+      RabbitFeed.log.info { { event: :publish_start, metadata: event.metadata } }
       ProducerConnection.instance.publish event.serialize, (options name, timestamp)
-      RabbitFeed.log.info {{ event: :publish_end, metadata: event.metadata }}
+      RabbitFeed.log.info { { event: :publish_end, metadata: event.metadata } }
       event
     end
 
     private
 
-    def metadata version, name, timestamp
+    def metadata(version, name, timestamp)
       {
         'application'    => RabbitFeed.configuration.application,
         'host'           => Socket.gethostname,
@@ -26,20 +26,20 @@ module RabbitFeed
         'created_at_utc' => timestamp.iso8601(6),
         'version'        => version,
         'name'           => name,
-        'schema_version' => Event::SCHEMA_VERSION,
+        'schema_version' => Event::SCHEMA_VERSION
       }
     end
 
-    def routing_key event_name
+    def routing_key(event_name)
       "#{RabbitFeed.environment}#{RabbitFeed.configuration.route_prefix_extension}.#{RabbitFeed.configuration.application}.#{event_name}"
     end
 
-    def options event_name, timestamp
+    def options(event_name, timestamp)
       {
         routing_key: (routing_key event_name),
         type:        event_name,
         app_id:      RabbitFeed.configuration.application,
-        timestamp:   timestamp.to_i,
+        timestamp:   timestamp.to_i
       }
     end
   end

data/lib/rabbit_feed/producer_connection.rb

@@ -1,6 +1,5 @@
 module RabbitFeed
   class ProducerConnection < RabbitFeed::Connection
-
     PUBLISH_OPTIONS = {
       persistent: true, # Persist the message to disk
       mandatory:  true, # Return the message if it can't be routed to a queue
@@ -12,24 +11,24 @@ module RabbitFeed
       no_declare:  false,  # Create the exchange if it does not exist
     }.freeze
 
-    def self.handle_returned_message return_info, content
-      RabbitFeed.log.error {{ event: :returned_message, return_info: return_info }}
-      RabbitFeed.exception_notify (ReturnedMessageError.new return_info)
+    def self.handle_returned_message(return_info, _content)
+      RabbitFeed.log.error { { event: :returned_message, return_info: return_info } }
+      RabbitFeed.exception_notify(ReturnedMessageError.new(return_info))
     end
 
     def initialize
       super
       @exchange = channel.exchange RabbitFeed.configuration.exchange, exchange_options
-      RabbitFeed.log.info {{ event: :exchange_declared, exchange: RabbitFeed.configuration.exchange, options: exchange_options }}
-      exchange.on_return do |return_info, properties, content|
+      RabbitFeed.log.info { { event: :exchange_declared, exchange: RabbitFeed.configuration.exchange, options: exchange_options } }
+      exchange.on_return do |return_info, _properties, content|
         RabbitFeed::ProducerConnection.handle_returned_message return_info, content
       end
     end
 
-    def publish message, options
+    def publish(message, options)
       synchronized do
         bunny_options = (options.merge PUBLISH_OPTIONS)
-        RabbitFeed.log.debug {{ event: :publish, options: options, exchange: RabbitFeed.configuration.exchange }}
+        RabbitFeed.log.debug { { event: :publish, options: options, exchange: RabbitFeed.configuration.exchange } }
         exchange.publish message, bunny_options
       end
     end
@@ -40,7 +39,7 @@ module RabbitFeed
 
     def exchange_options
       {
-        auto_delete: RabbitFeed.configuration.auto_delete_exchange,
+        auto_delete: RabbitFeed.configuration.auto_delete_exchange
       }.merge EXCHANGE_OPTIONS
     end
   end

data/lib/rabbit_feed/testing_support/rspec_matchers/publish_event.rb

@@ -1,100 +1,63 @@
-module RabbitFeed
-  module TestingSupport
-    module RSpecMatchers
-      class PublishEvent
-        attr_reader :expected_event
-
-        def initialize(expected_event, expected_payload)
-          @expected_event   = expected_event
-          @expected_payload = expected_payload
-        end
-
-        def matches?(given_proc, negative_expectation = false)
-          execute_proc(given_proc)
-
-          if block_given? && actual_event
-            yield actual_event.payload
-          else
-            received_expected_event = actual_event.present?
-            with_expected_payload = negative_expectation
-
-            if received_expected_event && !with_expected_payload
-              with_expected_payload = expected_payload.nil? || actual_event.payload == expected_payload
-            end
-            return received_expected_event && with_expected_payload
-          end
-        end
-
-        alias == matches?
-
-        def does_not_match?(given_proc)
-          !matches?(given_proc, :negative_expectation)
-        end
-
-        def failure_message
-          "expected #{expected_event} with #{expected_payload || 'some payload'} but instead received #{received_events_message}"
-        end
-
-        def negative_failure_message
-          "expected no #{expected_event} event, but received one anyways"
-        end
-
-        alias failure_message_when_negated negative_failure_message
-
-        def description
-          "publish_event #{expected_event}"
-        end
-
-        def supports_block_expectations?
-          true
-        end
-
-        def with(expected_payload=nil, &block)
-          if !!@expected_payload
-            ::Kernel.warn "`publish_event` was called with an expected payload already, anything in `with` is ignored"
-          else
-            @expected_payload = expected_payload || block
-          end
-
-          self
-        end
+require 'rspec/expectations'
+
+module TestingSupport
+  RSpec::Matchers.define :publish_event do |expected_event, expected_payload = nil|
+    match do |given_proc|
+      RabbitFeed::TestingSupport.published_events.clear
+      given_proc.call rescue nil
+      actual_event = first_matching_event(expected_event)
+      if actual_event.nil?
+        false
+      elsif expected_payload
+        actual_event.payload == expected_payload
+      elsif @included_in_payload
+        (@included_in_payload.to_a - actual_event.payload.to_a).empty?
+      elsif @asserting_block
+        @asserting_block.call(actual_event.payload)
+      else
+        true
+      end
+    end
 
-        private
+    failure_message do |_str|
+      "expected #{expected_event} with #{expected_payload || @included_in_payload || 'some payload'} but instead received #{received_events_message}"
+    end
 
-        def execute_proc(given_proc)
-          unless given_proc.respond_to?(:call)
-            ::Kernel.warn "`publish_event` was called with non-proc object #{given_proc.inspect}"
-            return false
-          end
+    failure_message_when_negated do |_str|
+      "expected no #{expected_event} event, but received one anyways"
+    end
 
-          TestingSupport.published_events.clear
-          given_proc.call
-        rescue
-        end
+    chain :including do |included_in_payload|
+      if expected_payload
+        Kernel.warn '`publish_event` was called with an expected payload already, anything in `including` is ignored'
+      else
+        @included_in_payload = included_in_payload
+      end
+    end
 
-        def actual_event
-          TestingSupport.published_events.detect do |event|
-            event.name == expected_event
-          end
-        end
+    chain :asserting do |&block|
+      if expected_payload || @included_in_payload
+        Kernel.warn '`publish_event` was called with an expected payload already, anything in `asserting` is ignored'
+      else
+        @asserting_block = block
+      end
+    end
 
-        def expected_payload
-          @expected_payload.respond_to?(:call) ? @expected_payload.call : @expected_payload
-        end
+    supports_block_expectations
 
-        def received_events_message
-          if TestingSupport.published_events.any?
-            TestingSupport.published_events.map do |received_event|
-              "#{received_event.name} with #{received_event.payload}"
-            end
-          else
-            'no events'
-          end
-        end
+    def first_matching_event(expected_event)
+      RabbitFeed::TestingSupport.published_events.detect do |event|
+        event.name == expected_event
       end
+    end
 
-      def publish_event(expected_event, expected_payload = nil)
-        PublishEvent.new(expected_event, expected_payload)
+    def received_events_message
+      if RabbitFeed::TestingSupport.published_events.any?
+        RabbitFeed::TestingSupport.published_events.map do |received_event|
+          "#{received_event.name} with #{received_event.payload}"
+        end
+      else
+        'no events'
       end
     end
   end

data/lib/rabbit_feed/testing_support/test_rabbit_feed_consumer.rb

@@ -1,8 +1,7 @@
 module RabbitFeed
   module TestingSupport
     class TestRabbitFeedConsumer
-
-      def consume_event event
+      def consume_event(event)
         RabbitFeed::Consumer.event_routing.handle_event event
       end
     end

data/lib/rabbit_feed/testing_support/testing_helpers.rb

@@ -1,7 +1,6 @@
 module RabbitFeed
   module TestingSupport
     module TestingHelpers
-
       def rabbit_feed_consumer
         TestRabbitFeedConsumer.new
       end

data/lib/rabbit_feed/testing_support.rb

@@ -8,29 +8,28 @@ module RabbitFeed
 
     attr_accessor :published_events
 
-    def setup rspec_config
+    def setup(rspec_config)
       RabbitFeed.environment ||= 'test'
       capture_published_events rspec_config
       include_support rspec_config
     end
 
-    def capture_published_events rspec_config
+    def capture_published_events(rspec_config)
       rspec_config.before :each do
         TestingSupport.capture_published_events_in_context(self)
       end
     end
 
-    def capture_published_events_in_context context
+    def capture_published_events_in_context(context)
       TestingSupport.published_events = []
       mock_connection = context.double(:rabbitmq_connection)
       context.allow(RabbitFeed::ProducerConnection).to context.receive(:instance).and_return(mock_connection)
-      context.allow(mock_connection).to context.receive(:publish) do |serialized_event, routing_key|
+      context.allow(mock_connection).to context.receive(:publish) do |serialized_event, _routing_key|
         TestingSupport.published_events << (Event.deserialize serialized_event)
       end
     end
 
-    def include_support rspec_config
-      rspec_config.include(RabbitFeed::TestingSupport::RSpecMatchers)
+    def include_support(rspec_config)
       rspec_config.include(RabbitFeed::TestingSupport::TestingHelpers)
     end
   end

data/lib/rabbit_feed/version.rb

@@ -1,3 +1,3 @@
 module RabbitFeed
-  VERSION = '2.4.4'
+  VERSION = '3.0.0'.freeze
 end

data/lib/rabbit_feed.rb

@@ -32,19 +32,18 @@ module RabbitFeed
     @configuration ||= (Configuration.load configuration_file_path, environment, application)
   end
 
-  def exception_notify exception
-    if defined? Airbrake
-      if defined?(Airbrake::VERSION) && Airbrake::VERSION.to_i < 5
-        (Airbrake.notify_or_ignore exception) if Airbrake.configuration.public?
-      elsif defined?(Airbrake::AIRBRAKE_VERSION) && Airbrake::AIRBRAKE_VERSION.to_i >= 5
-        if RabbitFeed.configuration.consumer_exit_after_fail
-          # Will need to send the notification right away, otherwise the `exit` would kill the
-          # Airbrake before the notification is sent out
-          Airbrake.notify_sync exception
-        else
-          # Airbrake notify default to sending notification asynchronously
-          Airbrake.notify exception
-        end
+  def exception_notify(exception)
+    return unless defined?(Airbrake)
+    if defined?(Airbrake::VERSION) && Airbrake::VERSION.to_i < 5
+      (Airbrake.notify_or_ignore exception) if Airbrake.configuration.public?
+    elsif defined?(Airbrake::AIRBRAKE_VERSION) && Airbrake::AIRBRAKE_VERSION.to_i >= 5
+      if RabbitFeed.configuration.consumer_exit_after_fail
+        # Will need to send the notification right away, otherwise the `exit` would kill the
+        # Airbrake before the notification is sent out
+        Airbrake.notify_sync exception
+      else
+        # Airbrake notify default to sending notification asynchronously
+        Airbrake.notify exception
       end
     end
   end

data/rabbit_feed.gemspec

@@ -8,31 +8,33 @@ Gem::Specification.new do |spec|
   spec.version       = RabbitFeed::VERSION
   spec.authors       = ['Simply Business']
   spec.email         = ['tech@simplybusiness.co.uk']
-  spec.description   = %q{A gem providing asynchronous event publish and subscribe capabilities with RabbitMQ.}
-  spec.summary       = %q{Enables your Ruby applications to perform centralized event logging with RabbitMq}
+  spec.description   = 'A gem providing asynchronous event publish and subscribe capabilities with RabbitMQ.'
+  spec.summary       = 'Enables your Ruby applications to perform centralized event logging with RabbitMq'
   spec.homepage      = 'https://github.com/simplybusiness/rabbit_feed'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
   # Gem for interfacing with RabbitMq
-  spec.add_dependency 'bunny', '>= 2.0.0', '< 2.1.0'
+  spec.add_dependency 'bunny', '>= 2.0.0', '< 2.7.0'
   # We use some helpers from ActiveSupport
-  spec.add_dependency 'activesupport', '>= 3.2.0', '< 5.0.0'
+  spec.add_dependency 'activesupport', '>= 3.2.0', '< 6.0.0'
   # We use validations from ActiveModel
-  spec.add_dependency 'activemodel', '>= 3.2.0', '< 5.0.0'
+  spec.add_dependency 'activemodel', '>= 3.2.0', '< 6.0.0'
   # Manages process pidfile
-  spec.add_dependency 'pidfile'
+  spec.add_dependency 'pidfile', '~> 0.3'
   # Schema definitions and serialization for events
-  spec.add_dependency 'avro', '>= 1.5.4', '< 1.8.0'
+  spec.add_dependency 'avro', '>= 1.5.4', '< 1.9.0'
 
-  spec.add_development_dependency 'codeclimate-test-reporter'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '>=2.14.0', '< 3.3.0'
-  spec.add_development_dependency 'rspec-its'
-  spec.add_development_dependency 'rutabaga'
-  spec.add_development_dependency 'timecop'
+  spec.add_development_dependency 'codeclimate-test-reporter', '~> 1.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.5'
+  spec.add_development_dependency 'rspec-its', '~> 1.2'
+  spec.add_development_dependency 'rubocop', '~> 0.46'
+  spec.add_development_dependency 'rutabaga', '~> 2.1'
+  spec.add_development_dependency 'simplecov', '~> 0.12'
+  spec.add_development_dependency 'timecop', '~> 0.8'
 end

data/run_benchmark

@@ -6,15 +6,16 @@ echo 'Starting test of rails application...'
 # Start the rails application
 echo 'Starting rails application...'
 pushd example/rails_app >/dev/null
-nodenv local v0.10 >/dev/null
-bundle exec rake db:reset RAILS_ENV=development
+bundle >/dev/null
+bin/rails db:environment:set RAILS_ENV=development
+bundle exec rake db:reset
 bundle exec unicorn -c config/unicorn.rb -E development -D
 sleep 1
 popd >/dev/null
 echo 'Rails application started'
 
 # Test publishing via the rails application
-siege -c 10 -r 10 -q -b "http://localhost:8080/beavers POST beaver[name]=`date '+%m/%d/%y %H:%M:%S'`"
+siege -c 10 -r 10 -b "http://localhost:8080/beavers POST beaver[name]=`date '+%m/%d/%y %H:%M:%S'`"
 sleep 4
 
 # Stop the rails application

data/run_example

@@ -16,8 +16,8 @@ echo 'Non rails application consumer started'
 echo 'Starting rails application consumer...'
 pushd example/rails_app >/dev/null
 bundle >/dev/null
+bin/rails db:environment:set RAILS_ENV=development
 bundle exec rake db:reset
-bundle exec rake db:reset RAILS_ENV=test
 bundle exec rake
 bundle exec rabbit_feed consume --environment development --daemon --verbose
 sleep 1

data/spec/features/step_definitions/connectivity_steps.rb

@@ -4,7 +4,7 @@ step 'I am consuming' do
   set_event_routing
   set_event_definitions
   RabbitFeed::ConsumerConnection.instance # Bind the queue
-  @consumer_thread = Thread.new{ RabbitFeed::Consumer.run }
+  @consumer_thread = Thread.new { RabbitFeed::Consumer.run }
 end
 
 step 'I publish an event' do
@@ -27,23 +27,20 @@ step 'the event remains on the queue' do
 end
 
 module Turnip::Steps
-
-  def publish event_name
+  def publish(event_name)
     @event_text = "#{event_name}_#{Time.now.iso8601(6)}"
-    RabbitFeed::Producer.publish_event event_name, { 'field' => @event_text }
+    RabbitFeed::Producer.publish_event event_name, 'field' => @event_text
   end
 
-  def assert_event_presence event
+  def assert_event_presence(event)
     expect(event).to_not be_nil
     expect(event.payload[:field]).to eq @event_text
   end
 
   def wait_for_event
     begin
-      Timeout::timeout(2.0) do
-        until @consumed_events.any? do
-          sleep 0.1
-        end
+      Timeout.timeout(2.0) do
+        sleep 0.1 until @consumed_events.any?
       end
     rescue Timeout::Error
     end