railway-ipc 0.1.6 → 2.0.0

data/lib/railway_ipc/errors.rb

@@ -1 +1,9 @@
-class RailwayIpc::InvalidProtobuf < StandardError; end
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+class RailwayIpc::Error < StandardError; end
+class RailwayIpc::InvalidProtobuf < RailwayIpc::Error; end
+class RailwayIpc::FailedToStoreOutgoingMessage < RailwayIpc::Error; end
+class RailwayIpc::IncomingMessage::ParserError < RailwayIpc::Error; end
+class RailwayIpc::IncomingMessage::InvalidMessage < RailwayIpc::Error; end
+# rubocop:enable Style/ClassAndModuleChildren

data/lib/railway_ipc/handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class Handler
     class << self
@@ -9,15 +11,27 @@ module RailwayIpc
     end
 
     def handle(message)
-      RailwayIpc.logger.info(message, 'Handling message')
+      RailwayIpc.logger.info('Handling message', log_message_options(message))
       response = self.class.block.call(message)
       if response.success?
-        RailwayIpc.logger.info(message, 'Successfully handled message')
+        RailwayIpc.logger.info('Successfully handled message', log_message_options(message))
       else
-        RailwayIpc.logger.error(message, 'Failed to handle message')
+        RailwayIpc.logger.error('Failed to handle message', log_message_options(message))
       end
 
       response
     end
+
+    private
+
+    def log_message_options(message)
+      {
+        feature: 'railway_ipc_consumer',
+        protobuf: {
+          type: message.class.name,
+          data: message
+        }
+      }
+    end
   end
 end

data/lib/railway_ipc/handler_store.rb

@@ -1,7 +1,10 @@
-require 'railway_ipc/handler_manifest'
+# frozen_string_literal: true
+
 module RailwayIpc
+  HandlerManifest = Struct.new(:message, :handler)
   class HandlerStore
     attr_reader :handler_map
+
     def initialize
       @handler_map = {}
     end
@@ -11,7 +14,7 @@ module RailwayIpc
     end
 
     def register(message:, handler:)
-      handler_map[message.to_s] = HandlerManifest.new(message: message, handler: handler)
+      handler_map[message.to_s] = HandlerManifest.new(message, handler)
     end
 
     def get(response_message)

data/lib/railway_ipc/incoming_message.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RailwayIpc
+  class IncomingMessage
+    attr_reader :type, :payload, :parsed_payload, :errors
+
+    def initialize(payload)
+      @parsed_payload = JSON.parse(payload)
+      @type = parsed_payload['type']
+      @payload = payload
+      @errors = {}
+    rescue JSON::ParserError => e
+      raise RailwayIpc::IncomingMessage::ParserError.new(e)
+    end
+
+    def uuid
+      decoded.uuid
+    end
+
+    def user_uuid
+      decoded.user_uuid
+    end
+
+    def correlation_id
+      decoded.correlation_id
+    end
+
+    def valid?
+      errors[:uuid] = 'uuid is required' unless uuid.present?
+      errors[:correlation_id] = 'correlation_id is required' unless correlation_id.present?
+      errors.none?
+    end
+
+    def decoded
+      @decoded ||=
+        begin
+          protobuf_msg = Base64.decode64(parsed_payload['encoded_message'])
+          decoder = Kernel.const_get(type)
+          decoder.decode(protobuf_msg)
+        rescue Google::Protobuf::ParseError => e
+          raise RailwayIpc::IncomingMessage::ParserError.new(e)
+        rescue NameError
+          RailwayIpc::Messages::Unknown.decode(protobuf_msg)
+        end
+    end
+
+    def stringify_errors
+      errors.values.join(', ')
+    end
+  end
+end

data/lib/railway_ipc/logger.rb

@@ -1,35 +1,41 @@
+# frozen_string_literal: true
+
 module RailwayIpc
+  # Custom logger that accepts a `device`, `level`, and `formatter`.
+  # `formatter` can be any object that responds to `call`; a
+  # `Logger::Formatter` is used if the argument is not provided.
+  #
+  # Here is an example formatter that uses `Oj` to format structured log
+  # messages:
+  #
+  # require 'oj'
+  # OjFormatter = proc do |severity, datetime, progname, data|
+  #   data.merge!(
+  #     name: progname,
+  #     timestamp: datetime,
+  #     severity: severity
+  #   )
+  #   Oj.dump(data, { mode: :compat, time_format: :xmlschema })
+  # end
+  #
+  # logger = RailwayIpc::Logger.new(STDOUT, Logger::INFO, OjFormatter)
+  #
   class Logger
-
-    attr_reader :logger
-
-    def initialize(logger)
-      @logger = logger
+    def initialize(device=STDOUT, level=::Logger::INFO, formatter=nil)
+      @logger = ::Logger.new(device)
+      @logger.level = level
+      @logger.formatter = formatter if formatter
     end
 
-    def info(message, statement)
-      logger.info("[#{message_header(message)}] #{statement}")
+    %w[fatal error warn info debug].each do |level|
+      define_method(level) do |message, data={}|
+        data.merge!(feature: 'railway_ipc') unless data.key?(:feature)
+        logger.send(level, data.merge(message: message))
+      end
     end
 
-    def warn(message, statement)
-      logger.warn("[#{message_header(message)}] #{statement}")
-    end
-
-    def debug(message, statement)
-      logger.debug("[#{message_header(message)}] #{statement}")
-    end
+    private
 
-    def error(message, statement)
-      logger.error("[#{message_header(message)}] #{statement}")
-    end
-
-    def log_exception(e)
-      logger.error(e)
-    end
-
-    def message_header(message)
-      log_statement = "message type: #{message.class}, uuid: #{message.uuid}, correlation_id: #{message.correlation_id}"
-      message.respond_to?(:user_uuid) ? "#{log_statement}, user_uuid: #{message.user_uuid}" : log_statement
-    end
+    attr_reader :logger
   end
 end

data/lib/railway_ipc/models/consumed_message.rb

@@ -1,37 +1,55 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class ConsumedMessage < ActiveRecord::Base
-    STATUSES = {
-      success: 'success',
-      processing: 'processing',
-      unknown_message_type: 'unknown_message_type',
-      failed_to_process: 'failed_to_process'
-    }
+    STATUS_SUCCESS = 'success'
+    STATUS_PROCESSING = 'processing'
+    STATUS_IGNORED = 'ignored'
+    STATUS_UNKNOWN_MESSAGE_TYPE = 'unknown_message_type'
+    STATUS_FAILED_TO_PROCESS = 'failed_to_process'
+
+    VALID_STATUSES = [
+      STATUS_SUCCESS,
+      STATUS_PROCESSING,
+      STATUS_IGNORED,
+      STATUS_UNKNOWN_MESSAGE_TYPE,
+      STATUS_FAILED_TO_PROCESS
+    ].freeze
 
     attr_reader :decoded_message
+
     self.table_name = 'railway_ipc_consumed_messages'
-    self.primary_key = 'uuid'
 
     validates :uuid, :status, presence: true
-    validates :status, inclusion: { in: STATUSES.values }
+    validates :status, inclusion: { in: VALID_STATUSES }
+
+    def self.create_processing(consumer, incoming_message)
+      # rubocop:disable Style/RedundantSelf
+      self.create!(
+        uuid: incoming_message.uuid,
+        status: STATUS_PROCESSING,
+        message_type: incoming_message.type,
+        user_uuid: incoming_message.user_uuid,
+        correlation_id: incoming_message.correlation_id,
+        queue: consumer.queue_name,
+        exchange: consumer.exchange_name,
+        encoded_message: incoming_message.payload
+      )
+      # rubocop:enable Style/RedundantSelf
+    end
 
-    def self.response_to_status(response)
-      if response.success?
-        STATUSES[:success]
-      else
-        STATUSES[:failed_to_process]
+    def update_with_lock(job)
+      with_lock('FOR UPDATE NOWAIT') do
+        job.run
+        self.status = job.status
+        save
       end
     end
 
     def processed?
-      self.status == STATUSES[:success]
-    end
-
-    def encoded_protobuf=(encoded_protobuf)
-      self.encoded_message = Base64.encode64(encoded_protobuf)
-    end
-
-    def decoded_message
-      @decoded_message ||= decode_message
+      # rubocop:disable Style/RedundantSelf
+      self.status == STATUS_SUCCESS
+      # rubocop:enable Style/RedundantSelf
     end
 
     private
@@ -39,18 +57,5 @@ module RailwayIpc
     def timestamp_attributes_for_create
       super << :inserted_at
     end
-
-    def decode_message
-      begin
-        message_class = Kernel.const_get(self.message_type)
-      rescue NameError
-        message_class = RailwayIpc::BaseMessage
-      end
-      message_class.decode(decoded_protobuf)
-    end
-
-    def decoded_protobuf
-      Base64.decode64(self.encoded_message)
-    end
   end
 end

data/lib/railway_ipc/models/published_message.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class PublishedMessage < ActiveRecord::Base
     self.table_name = 'railway_ipc_published_messages'
-    self.primary_key = "uuid"
+    self.primary_key = 'uuid'
 
     validates :uuid, :status, presence: true
 
     def self.store_message(exchange_name, message)
       encoded_message = RailwayIpc::Rabbitmq::Payload.encode(message)
-      self.create(
-          uuid: message.uuid,
-          message_type: message.class.to_s,
-          user_uuid: message.user_uuid,
-          correlation_id: message.correlation_id,
-          encoded_message: encoded_message,
-          status: "sent",
-          exchange: exchange_name
+      create!(
+        uuid: message.uuid,
+        message_type: message.class.to_s,
+        user_uuid: message.user_uuid,
+        correlation_id: message.correlation_id,
+        encoded_message: encoded_message,
+        status: 'sent',
+        exchange: exchange_name
       )
     end
 

data/lib/railway_ipc/publisher.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'singleton'
 
 module RailwayIpc
-  class Publisher < Sneakers::Publisher
+  class SingletonPublisher < Sneakers::Publisher
     include ::Singleton
 
     def self.exchange(exchange)
@@ -10,6 +12,7 @@ module RailwayIpc
 
     def self.exchange_name
       raise 'Subclass must set the exchange' unless @exchange_name
+
       @exchange_name
     end
 
@@ -18,13 +21,84 @@ module RailwayIpc
     end
 
     def publish(message, published_message_store=RailwayIpc::PublishedMessage)
-      RailwayIpc.logger.info(message, 'Publishing message')
+      RailwayIpc.logger.warn('DEPRECATED: Use new PublisherInstance class', log_message_options)
+      ensure_message_uuid(message)
+      ensure_correlation_id(message)
+      RailwayIpc.logger.info('Publishing message', log_message_options(message))
       result = super(RailwayIpc::Rabbitmq::Payload.encode(message))
       published_message_store.store_message(self.class.exchange_name, message)
       result
     rescue RailwayIpc::InvalidProtobuf => e
-      RailwayIpc.logger.error(message, 'Invalid protobuf')
+      RailwayIpc.logger.error('Invalid protobuf', log_message_options(message))
+      raise e
+    end
+
+    private
+
+    def ensure_message_uuid(message)
+      message.uuid = SecureRandom.uuid if message.uuid.blank?
+      message
+    end
+
+    def ensure_correlation_id(message)
+      message.correlation_id = SecureRandom.uuid if message.correlation_id.blank?
+      message
+    end
+
+    def log_message_options(message=nil)
+      options = { feature: 'railway_ipc_publisher', exchange: self.class.exchange_name }
+      message.nil? ? options : options.merge(protobuf: { type: message.class, data: message })
+    end
+  end
+end
+
+module RailwayIpc
+  class Publisher < Sneakers::Publisher
+    attr_reader :exchange_name, :message_store
+
+    def initialize(opts={})
+      @exchange_name = opts.fetch(:exchange_name)
+      @message_store = opts.fetch(:message_store, RailwayIpc::PublishedMessage)
+      connection = opts.fetch(:connection, nil)
+      options = {
+        exchange: exchange_name,
+        connection: connection,
+        exchange_type: :fanout
+      }.compact
+      super(options)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def publish(message)
+      message.uuid = SecureRandom.uuid if message.uuid.blank?
+      message.correlation_id = SecureRandom.uuid if message.correlation_id.blank?
+      RailwayIpc.logger.info('Publishing message', log_message_options(message))
+
+      stored_message = message_store.store_message(exchange_name, message)
+      super(RailwayIpc::Rabbitmq::Payload.encode(message))
+    rescue RailwayIpc::InvalidProtobuf => e
+      RailwayIpc.logger.error('Invalid protobuf', log_message_options(message))
+      raise e
+    rescue ActiveRecord::RecordInvalid => e
+      RailwayIpc.logger.error('Failed to store outgoing message', log_message_options(message))
+      raise RailwayIpc::FailedToStoreOutgoingMessage.new(e)
+    rescue StandardError => e
+      stored_message&.destroy
       raise e
     end
+    # rubocop:enable Metrics/AbcSize
+
+    private
+
+    def log_message_options(message)
+      {
+        feature: 'railway_ipc_publisher',
+        exchange: exchange_name,
+        protobuf: {
+          type: message.class,
+          data: message
+        }
+      }
+    end
   end
 end

data/lib/railway_ipc/rabbitmq/adapter.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   module Rabbitmq
     class Adapter
-      class TimeoutError < StandardError;
-      end
+      class TimeoutError < StandardError; end
       extend Forwardable
       attr_reader :connection, :exchange, :exchange_name, :queue, :queue_name, :channel
+
       def_delegators :connection,
                      :automatically_recover?,
                      :connected?,
@@ -14,24 +16,26 @@ module RailwayIpc
                      :port,
                      :user
 
-      def initialize(amqp_url: ENV["RAILWAY_RABBITMQ_CONNECTION_URL"], exchange_name:, queue_name: '', options: {})
+      def initialize(amqp_url: ENV['RAILWAY_RABBITMQ_CONNECTION_URL'], exchange_name:, queue_name: '', options: {})
         @queue_name = queue_name
         @exchange_name = exchange_name
         settings = AMQ::Settings.parse_amqp_url(amqp_url)
         vhost = settings[:vhost] || '/'
         @connection = Bunny.new({
-                                    host: settings[:host],
-                                    user: settings[:user],
-                                    pass: settings[:pass],
-                                    port: settings[:port],
-                                    vhost: vhost,
-                                    automatic_recovery: false,
-                                    logger: RailwayIpc.bunny_logger
-                                }.merge(options))
+          host: settings[:host],
+          user: settings[:user],
+          pass: settings[:pass],
+          port: settings[:port],
+          vhost: vhost,
+          automatic_recovery: false,
+          logger: RailwayIpc.logger
+        }.merge(options))
       end
 
-      def publish(message, options = {})
+      def publish(message, options={})
+        # rubocop:disable Style/SafeNavigation
         exchange.publish(message, options) if exchange
+        # rubocop:enable Style/SafeNavigation
       end
 
       def reply(message, from)
@@ -66,17 +70,19 @@ module RailwayIpc
         self
       end
 
-      def create_exchange(strategy: :fanout, options: {durable: true})
-        @exchange = Bunny::Exchange.new(connection.channel, :fanout, exchange_name, options)
+      def create_exchange(strategy: :fanout, options: { durable: true })
+        @exchange = Bunny::Exchange.new(connection.channel, strategy, exchange_name, options)
         self
       end
 
       def delete_exchange
+        # rubocop:disable Style/SafeNavigation
         exchange.delete if exchange
+        # rubocop:enable Style/SafeNavigation
         self
       end
 
-      def create_queue(options = {durable: true})
+      def create_queue(options={ durable: true })
         @queue = @channel.queue(queue_name, options)
         self
       end
@@ -87,7 +93,9 @@ module RailwayIpc
       end
 
       def delete_queue
+        # rubocop:disable Style/SafeNavigation
         queue.delete if queue
+        # rubocop:enable Style/SafeNavigation
         self
       end
     end