rabbit_feed 2.4.4 → 3.0.0

data/lib/rabbit_feed/client.rb

@@ -10,30 +10,27 @@ module RabbitFeed
       require_path: '.',
       config_file:  'config/rabbit_feed.yml',
       logfile:      'log/rabbit_feed.log',
-      pidfile:      'tmp/pids/rabbit_feed.pid',
-    }
+      pidfile:      'tmp/pids/rabbit_feed.pid'
+    }.freeze
     DEFAULTS.freeze
 
     attr_reader :command, :options
     validates_presence_of :command, :options
-    validates :command, inclusion: { in: %w(consume produce shutdown console), message: "%{value} is not a valid command" }
+    validates :command, inclusion: { in: %w(consume produce shutdown console), message: '%{value} is not a valid command' }
     validate :log_file_path_exists
     validate :config_file_exists
     validate :require_path_valid, unless: :console?
     validate :pidfile_path_exists, if: :daemonize?
     validate :environment_specified
 
-    def initialize arguments=ARGV
+    def initialize(arguments = ARGV)
       @command = arguments[0]
       @options = parse_options arguments
-
-      unless shutdown?
-        validate!
-
-        set_logging
-        set_configuration
-        load_dependancies unless console?
-      end
+      return if shutdown?
+      validate!
+      set_logging
+      set_configuration
+      load_dependancies unless console?
     end
 
     def run
@@ -43,25 +40,24 @@ module RabbitFeed
     private
 
     def validate!
-      raise Error.new errors.messages if invalid?
+      raise Error, errors.messages if invalid?
     end
 
     def log_file_path_exists
-      errors.add(:options, "log file path not found: '#{options[:logfile]}', specify this using the --logfile option") unless Dir.exists?(File.dirname(options[:logfile]))
+      errors.add(:options, "log file path not found: '#{options[:logfile]}', specify this using the --logfile option") unless Dir.exist?(File.dirname(options[:logfile]))
     end
 
     def config_file_exists
-      errors.add(:options, "configuration file not found: '#{options[:config_file]}', specify this using the --config option") unless File.exists?(options[:config_file])
+      errors.add(:options, "configuration file not found: '#{options[:config_file]}', specify this using the --config option") unless File.exist?(options[:config_file])
     end
 
     def require_path_valid
-      if require_rails? && !File.exist?("#{options[:require_path]}/config/application.rb")
-        errors.add(:options, 'point rabbit_feed to a Rails 3/4 application or a Ruby file to load your worker classes with --require')
-      end
+      return unless require_rails? && !File.exist?("#{options[:require_path]}/config/application.rb")
+      errors.add(:options, 'point rabbit_feed to a Rails 3/4 application or a Ruby file to load your worker classes with --require')
     end
 
     def pidfile_path_exists
-      errors.add(:options, "pid file path not found: '#{options[:pidfile]}', specify this using the --pidfile option") unless Dir.exists?(File.dirname(options[:pidfile]))
+      errors.add(:options, "pid file path not found: '#{options[:pidfile]}', specify this using the --pidfile option") unless Dir.exist?(File.dirname(options[:pidfile]))
     end
 
     def environment_specified
@@ -145,11 +141,10 @@ module RabbitFeed
       File.directory?(options[:require_path])
     end
 
-    def parse_options argv
+    def parse_options(argv)
       opts = {}
 
       parser = OptionParser.new do |o|
-
         o.on '-a', '--application VAL', 'Name of the application' do |arg|
           opts[:application] = arg
         end
@@ -190,7 +185,7 @@ module RabbitFeed
           opts[:pidfile] = arg
         end
 
-        o.on '-V', '--version', 'Print version and exit' do |arg|
+        o.on '-V', '--version', 'Print version and exit' do |_arg|
           puts "RabbitFeed #{RabbitFeed::VERSION}"
           exit 0
         end
@@ -204,6 +199,5 @@ module RabbitFeed
       parser.parse! argv
       DEFAULTS.merge opts
     end
-
   end
 end

data/lib/rabbit_feed/configuration.rb

@@ -7,8 +7,8 @@ module RabbitFeed
                 :consumer_exit_after_fail
     validates_presence_of :application, :environment, :exchange
 
-    def initialize options
-      RabbitFeed.log.info {{ event: :initialize_configuration, options: options.merge({password: :redacted}) }}
+    def initialize(options)
+      RabbitFeed.log.info { { event: :initialize_configuration, options: options.merge(password: :redacted) } }
 
       @host                      = options[:host]
       @hosts                     = options[:hosts]
@@ -28,10 +28,10 @@ module RabbitFeed
       validate!
     end
 
-    def self.load file_path, environment, application
-      RabbitFeed.log.info {{ event: :load_configuration_file, file_path: file_path, environment: environment, application: application }}
+    def self.load(file_path, environment, application)
+      RabbitFeed.log.info { { event: :load_configuration_file, file_path: file_path, environment: environment, application: application } }
 
-      raise ConfigurationError.new "The RabbitFeed configuration file path specified does not exist: #{file_path}" unless (File.exist? file_path)
+      raise ConfigurationError, "The RabbitFeed configuration file path specified does not exist: #{file_path}" unless File.exist? file_path
 
       options = read_configuration_file file_path, environment
       options[:environment] = environment
@@ -48,7 +48,7 @@ module RabbitFeed
     end
 
     def connection_options
-      Hash.new.tap do |options|
+      {}.tap do |options|
         options[:heartbeat] = heartbeat if heartbeat
         options[:connect_timeout] = connect_timeout if connect_timeout
         options[:host] = host if host
@@ -65,13 +65,14 @@ module RabbitFeed
 
     private
 
-    def self.read_configuration_file file_path, environment
+    def self.read_configuration_file(file_path, environment)
       raw_configuration = YAML.load(ERB.new(File.read(file_path)).result)
-      HashWithIndifferentAccess.new (raw_configuration[environment] || {})
+      HashWithIndifferentAccess.new(raw_configuration[environment] || {})
     end
+    private_class_method :read_configuration_file
 
     def validate!
-      raise ConfigurationError.new errors.messages if invalid?
+      raise ConfigurationError, errors.messages if invalid?
     end
   end
 end

data/lib/rabbit_feed/connection.rb

@@ -3,10 +3,10 @@ module RabbitFeed
     include Singleton
 
     def initialize
-      RabbitFeed.log.info {{ event: :connecting_to_rabbitmq, options: RabbitFeed.configuration.connection_options.merge({password: :redacted, logger: :redacted}) }}
+      RabbitFeed.log.info { { event: :connecting_to_rabbitmq, options: RabbitFeed.configuration.connection_options.merge(password: :redacted, logger: :redacted) } }
       @connection = Bunny.new RabbitFeed.configuration.connection_options
       @connection.start
-      RabbitFeed.log.info {{ event: :connected_to_rabbitmq }}
+      RabbitFeed.log.info { { event: :connected_to_rabbitmq } }
       @channel = @connection.create_channel
       @mutex = Mutex.new
     end
@@ -15,7 +15,7 @@ module RabbitFeed
 
     attr_reader :channel, :mutex
 
-    def synchronized &block
+    def synchronized
       mutex.synchronize do
         yield
       end

data/lib/rabbit_feed/console_consumer.rb

@@ -2,7 +2,7 @@ module RabbitFeed
   module ConsoleConsumer
     extend self
 
-    APPLICATION_NAME = 'rabbit_feed_console'
+    APPLICATION_NAME = 'rabbit_feed_console'.freeze
 
     def init
       @event_count = 0
@@ -10,10 +10,10 @@ module RabbitFeed
       route_all_events
       puts welcome_message
       ask_to_purge_queue unless queue_empty?
-      puts "Ready. Press CTRL+C to exit."
+      puts 'Ready. Press CTRL+C to exit.'
     end
 
-    def formatted event
+    def formatted(event)
       Formatter.new(event).to_s
     end
 
@@ -28,10 +28,9 @@ module RabbitFeed
     private
 
     def welcome_message
-"""RabbitFeed console starting at #{Time.now.utc}...
-Environment: #{RabbitFeed.environment}
-Queue: #{RabbitFeed.configuration.queue}
-"""
+      "RabbitFeed console starting at #{Time.now.utc}...\n"\
+      "Environment: #{RabbitFeed.environment}\n"\
+      "Queue: #{RabbitFeed.configuration.queue}"
     end
 
     def queue_empty?
@@ -39,15 +38,15 @@ Queue: #{RabbitFeed.configuration.queue}
     end
 
     def ask_to_purge_queue
-      puts "There are currently #{ConsumerConnection.instance.queue_depth} message(s) in the console's queue.\n"+
-      "Would you like to purge the queue before proceeding? (y/N)>"
+      puts "There are currently #{ConsumerConnection.instance.queue_depth} message(s) in the console's queue.\n"\
+           'Would you like to purge the queue before proceeding? (y/N)>'
       response = STDIN.gets.chomp
       purge_queue if response == 'y'
     end
 
     def purge_queue
       ConsumerConnection.instance.purge_queue
-      puts "Queue purged."
+      puts 'Queue purged.'
     end
 
     def route_all_events
@@ -56,7 +55,7 @@ Queue: #{RabbitFeed.configuration.queue}
         accept_from(:any) do
           event(:any) do |event|
             scope.increment_event_count
-            puts (scope.formatted event)
+            puts scope.formatted(event)
             puts scope.event_count_message
           end
         end
@@ -68,15 +67,14 @@ Queue: #{RabbitFeed.configuration.queue}
     end
 
     class Formatter
-
       BORDER_WIDTH = 100
-      BORDER_CHAR  = "-"
-      DIVIDER_CHAR = "*"
-      NEWLINE      = "\n"
+      BORDER_CHAR  = '-'.freeze
+      DIVIDER_CHAR = '*'.freeze
+      NEWLINE      = "\n".freeze
 
       attr_reader :event
 
-      def initialize event
+      def initialize(event)
         @event = event
       end
 
@@ -88,12 +86,12 @@ Queue: #{RabbitFeed.configuration.queue}
 
       def header
         event_detail = "#{event.name}: #{event.created_at_utc}"
-        border_filler = BORDER_CHAR*((BORDER_WIDTH - event_detail.length)/2)
-        border_filler+event_detail+border_filler
+        border_filler = BORDER_CHAR * ((BORDER_WIDTH - event_detail.length) / 2)
+        border_filler + event_detail + border_filler
       end
 
       def footer
-        BORDER_CHAR*BORDER_WIDTH
+        BORDER_CHAR * BORDER_WIDTH
       end
 
       def metadata
@@ -101,18 +99,18 @@ Queue: #{RabbitFeed.configuration.queue}
       end
 
       def divider
-        DIVIDER_CHAR*BORDER_WIDTH
+        DIVIDER_CHAR * BORDER_WIDTH
       end
 
       def payload
         pretty_print_hash 'Event payload', event.payload
       end
 
-      def pretty_print_hash description, hash
+      def pretty_print_hash(description, hash)
         '#' + description + NEWLINE +
-        hash.keys.sort.map do |key|
-          "#{key}: #{hash[key]}"
-        end.join(NEWLINE)
+          hash.keys.sort.map do |key|
+            "#{key}: #{hash[key]}"
+          end.join(NEWLINE)
       end
     end
   end

data/lib/rabbit_feed/consumer.rb

@@ -7,9 +7,9 @@ module RabbitFeed
     def run
       ConsumerConnection.instance.consume do |raw_event|
         event = Event.deserialize raw_event
-        RabbitFeed.log.info {{ event: :message_received, metadata: event.metadata }}
+        RabbitFeed.log.info { { event: :message_received, metadata: event.metadata } }
         event_routing.handle_event event
-        RabbitFeed.log.info {{ event: :message_processed, metadata: event.metadata }}
+        RabbitFeed.log.info { { event: :message_processed, metadata: event.metadata } }
       end
     end
   end

data/lib/rabbit_feed/consumer_connection.rb

@@ -1,6 +1,5 @@
 module RabbitFeed
   class ConsumerConnection < RabbitFeed::Connection
-
     SUBSCRIPTION_OPTIONS = {
       consumer_tag: Socket.gethostname, # Use the host name of the server
       manual_ack:   true, # Manually acknowledge messages once they've been processed
@@ -15,30 +14,30 @@ module RabbitFeed
       arguments:   {
         'x-ha-policy' => 'all', # Apply the queue on all mirrors
         'x-expires'   => SEVEN_DAYS_IN_MS, # Auto-delete the queue after a period of inactivity (in ms)
-        },
+      }
     }.freeze
 
     def initialize
       super
       channel.prefetch(1)
       @queue = channel.queue RabbitFeed.configuration.queue, queue_options
-      RabbitFeed.log.info {{ event: :queue_declared, queue: RabbitFeed.configuration.queue, options: queue_options }}
+      RabbitFeed.log.info { { event: :queue_declared, queue: RabbitFeed.configuration.queue, options: queue_options } }
       bind_on_accepted_routes
     end
 
-    def consume &block
+    def consume(&block)
       raise 'This connection already has a consumer subscribed' if connection_in_use?
       synchronized do
         begin
-          RabbitFeed.log.info {{ event: :subscribe_to_queue, queue: RabbitFeed.configuration.queue }}
+          RabbitFeed.log.info { { event: :subscribe_to_queue, queue: RabbitFeed.configuration.queue } }
 
-          consumer = queue.subscribe(SUBSCRIPTION_OPTIONS) do |delivery_info, properties, payload|
+          consumer = queue.subscribe(SUBSCRIPTION_OPTIONS) do |delivery_info, _properties, payload|
             handle_message delivery_info, payload, &block
           end
 
           sleep # Sleep indefinitely, as the consumer runs in its own thread
-        rescue SystemExit, Interrupt, SignalException
-          RabbitFeed.log.info {{ event: :unsubscribe_from_queue, queue: RabbitFeed.configuration.queue }}
+        rescue SystemExit, SignalException
+          RabbitFeed.log.info { { event: :unsubscribe_from_queue, queue: RabbitFeed.configuration.queue } }
         ensure
           (cancel_consumer consumer) if consumer.present?
         end
@@ -59,29 +58,29 @@ module RabbitFeed
 
     def queue_options
       {
-        auto_delete: RabbitFeed.configuration.auto_delete_queue,
+        auto_delete: RabbitFeed.configuration.auto_delete_queue
       }.merge QUEUE_OPTIONS
     end
 
     def bind_on_accepted_routes
       if RabbitFeed::Consumer.event_routing.present?
         RabbitFeed::Consumer.event_routing.accepted_routes.each do |accepted_route|
-          queue.bind(RabbitFeed.configuration.exchange, { routing_key: accepted_route })
-          RabbitFeed.log.info {{ event: :queue_bound, queue: RabbitFeed.configuration.queue, exchange: RabbitFeed.configuration.exchange, routing_key: accepted_route }}
+          queue.bind(RabbitFeed.configuration.exchange, routing_key: accepted_route)
+          RabbitFeed.log.info { { event: :queue_bound, queue: RabbitFeed.configuration.queue, exchange: RabbitFeed.configuration.exchange, routing_key: accepted_route } }
         end
       else
         queue.bind(RabbitFeed.configuration.exchange)
-        RabbitFeed.log.info {{ event: :queue_bound, queue: RabbitFeed.configuration.queue, exchange: RabbitFeed.configuration.exchange }}
+        RabbitFeed.log.info { { event: :queue_bound, queue: RabbitFeed.configuration.queue, exchange: RabbitFeed.configuration.exchange } }
       end
     end
 
-    def acknowledge delivery_info
+    def acknowledge(delivery_info)
       queue.channel.ack(delivery_info.delivery_tag)
-      RabbitFeed.log.debug {{ event: :acknowledge, delivery_tag: delivery_info.delivery_tag }}
+      RabbitFeed.log.debug { { event: :acknowledge, delivery_tag: delivery_info.delivery_tag } }
     end
 
-    def handle_message delivery_info, payload, &block
-      RabbitFeed.log.debug {{ event: :handling_message, delivery_tag: delivery_info.delivery_tag }}
+    def handle_message(delivery_info, payload)
+      RabbitFeed.log.debug { { event: :handling_message, delivery_tag: delivery_info.delivery_tag } }
       begin
         yield payload
         acknowledge delivery_info
@@ -91,21 +90,21 @@ module RabbitFeed
       end
     end
 
-    def cancel_consumer consumer
+    def cancel_consumer(consumer)
       cancel_ok = consumer.cancel
-      RabbitFeed.log.debug {{ event: :consumer_cancelled, status: cancel_ok, queue: RabbitFeed.configuration.queue }}
+      RabbitFeed.log.debug { { event: :consumer_cancelled, status: cancel_ok, queue: RabbitFeed.configuration.queue } }
     end
 
-    def negative_acknowledge delivery_info
+    def negative_acknowledge(delivery_info)
       # Tell rabbit that we were unable to process the message
       # This will re-queue the message
       queue.channel.nack(delivery_info.delivery_tag, false, true)
-      RabbitFeed.log.debug {{ event: :negative_acknowledge, delivery_tag: delivery_info.delivery_tag }}
+      RabbitFeed.log.debug { { event: :negative_acknowledge, delivery_tag: delivery_info.delivery_tag } }
     end
 
-    def handle_processing_exception delivery_info, exception
+    def handle_processing_exception(delivery_info, exception)
       negative_acknowledge delivery_info
-      RabbitFeed.log.error {{ event: :processing_exception, delivery_tag: delivery_info.delivery_tag, message: exception.message, backtrace: exception.backtrace.join(',') }}
+      RabbitFeed.log.error { { event: :processing_exception, delivery_tag: delivery_info.delivery_tag, message: exception.message, backtrace: exception.backtrace.join(',') } }
       RabbitFeed.exception_notify exception
     end
   end

data/lib/rabbit_feed/event.rb

@@ -2,14 +2,14 @@ module RabbitFeed
   class Event
     include ActiveModel::Validations
 
-    SCHEMA_VERSION = '2.0.0'
+    SCHEMA_VERSION = '2.0.0'.freeze
 
     attr_reader :schema, :payload, :metadata, :sensitive_fields
     validates :metadata, presence: true
     validates :payload, length: { minimum: 0, allow_nil: false, message: 'can\'t be nil' }
     validate  :required_metadata
 
-    def initialize metadata, payload={}, schema=nil, sensitive_fields=[]
+    def initialize(metadata, payload = {}, schema = nil, sensitive_fields = [])
       @schema   = schema
       @payload  = payload.with_indifferent_access if payload
       @metadata = metadata.with_indifferent_access if metadata
@@ -40,8 +40,7 @@ module RabbitFeed
     end
 
     class << self
-
-      def deserialize serialized_event
+      def deserialize(serialized_event)
         datum_reader = Avro::IO::DatumReader.new
         reader       = Avro::DataFile::Reader.new (StringIO.new serialized_event), datum_reader
         event_hash   = nil
@@ -49,25 +48,7 @@ module RabbitFeed
           event_hash = datum
         end
         reader.close
-        if (version_1? event_hash)
-          new_from_version_1 event_hash, datum_reader.readers_schema
-        else
-          new event_hash['metadata'], event_hash['payload'], datum_reader.readers_schema
-        end
-      end
-
-      private
-
-      def version_1? event_hash
-        %w(metadata payload).none?{|key| event_hash.has_key? key}
-      end
-
-      def new_from_version_1 metadata_and_payload, schema
-        metadata = {}
-        %w(application name host version environment created_at_utc).each do |field|
-          metadata[field] = metadata_and_payload.delete field
-        end
-        new metadata, metadata_and_payload, schema
+        new event_hash['metadata'], event_hash['payload'], datum_reader.readers_schema
       end
     end
 
@@ -75,18 +56,17 @@ module RabbitFeed
 
     def sensitive_proof_payload
       sensitive_fields.each_with_object(payload.dup) do |field, clean_payload|
-        clean_payload[field] = "[REMOVED]" if clean_payload.key?(field)
+        clean_payload[field] = '[REMOVED]' if clean_payload.key?(field)
       end
     end
 
     def validate!
-      raise Error.new "Invalid event: #{errors.messages}" if invalid?
+      raise Error, "Invalid event: #{errors.messages}" if invalid?
     end
 
     def required_metadata
-      if metadata
-        errors.add(:metadata, 'name field is required') if metadata[:name].blank?
-      end
+      return unless metadata
+      errors.add(:metadata, 'name field is required') if metadata[:name].blank?
     end
   end
 end

data/lib/rabbit_feed/event_definitions.rb

@@ -1,13 +1,12 @@
 module RabbitFeed
   class EventDefinitions
-
     class Field
       include ActiveModel::Validations
 
       attr_reader :name, :type, :definition
       validates_presence_of :name, :type, :definition
 
-      def initialize name, type, definition
+      def initialize(name, type, definition)
         @name       = name
         @type       = type
         @definition = definition
@@ -21,7 +20,7 @@ module RabbitFeed
       private
 
       def validate!
-        raise ConfigurationError.new "Bad field specification for #{name}: #{errors.messages}" if invalid?
+        raise ConfigurationError, "Bad field specification for #{name}: #{errors.messages}" if invalid?
       end
     end
 
@@ -33,24 +32,24 @@ module RabbitFeed
       validate :schema_parseable
       validates :version, format: { with: /\A\d+\.\d+\.\d+\z/, message: 'must be in *.*.* format' }
 
-      def initialize name, version
+      def initialize(name, version)
         @name    = name
         @version = version
         @fields  = []
         @sensitive_fields = []
       end
 
-      def payload_contains &block
-        self.instance_eval(&block)
+      def payload_contains(&block)
+        instance_eval(&block)
       end
 
-      def field name, options
+      def field(name, options)
         sensitive_fields << name.to_s if options.delete(:sensitive)
         fields << (Field.new name, options[:type], options[:definition])
       end
 
-      def defined_as &block
-        @definition = block.call if block.present?
+      def defined_as(&block)
+        @definition = yield if block.present?
       end
 
       def payload_schema
@@ -65,23 +64,23 @@ module RabbitFeed
           (Field.new 'version',        'string', 'The version of the event payload'),
           (Field.new 'schema_version', 'string', 'The version of the event schema'),
           (Field.new 'name',           'string', 'The name of the event'),
-          (Field.new 'created_at_utc', 'string', 'The UTC time that the event was created'),
+          (Field.new 'created_at_utc', 'string', 'The UTC time that the event was created')
         ].map(&:schema) }
       end
 
       def event_schema
         [
           { name: 'payload', type: payload_schema, doc: 'The event payload (defined by the source system)' },
-          { name: 'metadata', type: metadata_schema, doc: 'The event metadata (defined by rabbit feed)' },
+          { name: 'metadata', type: metadata_schema, doc: 'The event metadata (defined by rabbit feed)' }
         ]
       end
 
       def schema
-        @schema ||= (Avro::Schema.parse ({ name: name, type: 'record', doc: definition, fields: event_schema }.to_json))
+        @schema ||= Avro::Schema.parse({ name: name, type: 'record', doc: definition, fields: event_schema }.to_json)
       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
 
       private
@@ -99,13 +98,13 @@ module RabbitFeed
       @events = {}
     end
 
-    def define_event name, options, &block
+    def define_event(name, options, &block)
       events[name] = Event.new name, options[:version]
       events[name].instance_eval(&block)
       events[name].validate!
     end
 
-    def [] name
+    def [](name)
       events[name]
     end
   end