railway-ipc 0.1.7 → 2.0.1

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

data/lib/railway_ipc/rabbitmq/payload.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   module Rabbitmq
     class Payload
@@ -7,6 +9,7 @@ module RailwayIpc
         type = message.class.to_s
         begin
           message = Base64.encode64(message.class.encode(message))
+        # TODO: also need to rescue Google::Protobuf::TypeError
         rescue NoMethodError
           raise RailwayIpc::InvalidProtobuf.new("Message #{message} is not a valid protobuf")
         end
@@ -15,8 +18,8 @@ module RailwayIpc
 
       def self.decode(message)
         message = JSON.parse(message)
-        type = message["type"]
-        message = Base64.decode64(message["encoded_message"])
+        type = message['type']
+        message = Base64.decode64(message['encoded_message'])
         new(type, message)
       end
 
@@ -25,12 +28,14 @@ module RailwayIpc
         @message = message
       end
 
+      # rubocop:disable Lint/ToJSON
       def to_json
         {
-            type: type,
-            encoded_message: message
+          type: type,
+          encoded_message: message
         }.to_json
       end
+      # rubocop:enable Lint/ToJSON
     end
   end
 end

data/lib/railway_ipc/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class Railtie < Rails::Railtie
     railtie_name :railway_ipc

data/lib/railway_ipc/responder.rb

@@ -1,17 +1,24 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class Responder
     def self.respond(&block)
       @block = block
     end
 
-    def self.block
-      @block
+    class << self
+      attr_reader :block
     end
 
     def respond(request)
-      RailwayIpc.logger.info(request, "Responding to request")
+      RailwayIpc.logger.info(
+        'Responding to request',
+        protobuf: { type: request.class, data: request },
+        feature: 'railway_ipc_request'
+      )
       response = self.class.block.call(request)
       raise ResponseTypeError.new(response.class) unless response.is_a?(Google::Protobuf::MessageExts)
+
       response
     end
 

data/lib/railway_ipc/response.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class Response
     attr_reader :body, :success
-    def initialize(message, success:true)
+
+    def initialize(message, success: true)
       @body = message
       @success = success
     end

data/lib/railway_ipc/rpc/client/client.rb

@@ -1,12 +1,15 @@
-require "railway_ipc/rpc/client/client_response_handlers"
-require "railway_ipc/rpc/concerns/publish_location_configurable"
-require "railway_ipc/rpc/concerns/error_adapter_configurable"
-require "railway_ipc/rpc/client/errors/timeout_error"
+# frozen_string_literal: true
+
+require 'railway_ipc/rpc/client/client_response_handlers'
+require 'railway_ipc/rpc/concerns/publish_location_configurable'
+require 'railway_ipc/rpc/concerns/error_adapter_configurable'
+require 'railway_ipc/rpc/client/errors/timeout_error'
 
 module RailwayIpc
   class Client
     attr_accessor :response_message, :request_message
     attr_reader :rabbit_connection, :message
+
     extend RailwayIpc::RPC::PublishLocationConfigurable
     extend RailwayIpc::RPC::ErrorAdapterConfigurable
 
@@ -18,12 +21,12 @@ module RailwayIpc
       RPC::ClientResponseHandlers.instance.register(response_type)
     end
 
-    def initialize(request_message, opts = { automatic_recovery: false }, rabbit_adapter: RailwayIpc::Rabbitmq::Adapter)
+    def initialize(request_message, opts={ automatic_recovery: false }, rabbit_adapter: RailwayIpc::Rabbitmq::Adapter)
       @rabbit_connection = rabbit_adapter.new(exchange_name: self.class.exchange_name, options: opts)
       @request_message = request_message
     end
 
-    def request(timeout = 10)
+    def request(timeout=10)
       setup_rabbit_connection
       attach_reply_queue_to_message
       publish_message
@@ -35,18 +38,28 @@ module RailwayIpc
       RailwayIpc::RPC::ClientResponseHandlers.instance.registered
     end
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def process_payload(response)
       decoded_payload = decode_payload(response)
       case decoded_payload.type
       when *registered_handlers
         @message = get_message_class(decoded_payload).decode(decoded_payload.message)
-        RailwayIpc.logger.info(message, "Handling response")
+        RailwayIpc.logger.info(
+          'Handling response',
+          feature: 'railway_ipc_consumer',
+          exchange: self.class.exchange_name,
+          queue: self.class.queue_name,
+          protobuf: { type: message.class, data: message }
+        )
         RailwayIpc::Response.new(message, success: true)
       else
         @message = LearnIpc::ErrorMessage.decode(decoded_payload.message)
-        raise RailwayIpc::UnhandledMessageError, "#{self.class} does not know how to handle #{decoded_payload.type}"
+        raise RailwayIpc::UnhandledMessageError.new("#{self.class} does not know how to handle #{decoded_payload.type}")
       end
     end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
 
     def setup_rabbit_connection
       rabbit_connection
@@ -60,7 +73,9 @@ module RailwayIpc
         self.response_message = process_payload(payload)
       end
     rescue RailwayIpc::Rabbitmq::Adapter::TimeoutError
+      # rubocop:disable Style/RedundantSelf
       error = self.class.rpc_error_adapter_class.error_message(TimeoutError.new, self.request_message)
+      # rubocop:enable Style/RedundantSelf
       self.response_message = RailwayIpc::Response.new(error, success: false)
     rescue StandardError
       self.response_message = RailwayIpc::Response.new(message, success: false)
@@ -70,12 +85,14 @@ module RailwayIpc
 
     private
 
-    def log_exception(e, payload)
-      RailwayIpc.logger.log_exception(
-        feature: "railway_consumer",
-        error: e.class,
-        error_message: e.message,
-        payload: decode_for_error(e, payload),
+    def log_exception(exception, payload)
+      RailwayIpc.logger.error(
+        exception.message,
+        feature: 'railway_ipc_consumer',
+        exchange: self.class.exchange_name,
+        queue: self.class.queue_name,
+        error: exception.class,
+        payload: decode_for_error(exception, payload)
       )
     end
 
@@ -92,13 +109,21 @@ module RailwayIpc
     end
 
     def publish_message
-      RailwayIpc.logger.info(request_message, "Sending request")
-      rabbit_connection.publish(RailwayIpc::Rabbitmq::Payload.encode(request_message), routing_key: "")
+      RailwayIpc.logger.info(
+        'Sending request',
+        feature: 'railway_ipc_publisher',
+        exchange: self.class.exchange_name,
+        protobuf: { type: request_message.class, data: request_message }
+      )
+      rabbit_connection.publish(RailwayIpc::Rabbitmq::Payload.encode(request_message), routing_key: '')
     end
 
-    def decode_for_error(e, payload)
-      return e.message unless payload
+    def decode_for_error(exception, payload)
+      return exception.message unless payload
+
+      # rubocop:disable Style/RedundantSelf
       self.class.rpc_error_adapter_class.error_message(payload, self.request_message)
+      # rubocop:enable Style/RedundantSelf
     end
   end
 end

data/lib/railway_ipc/rpc/client/client_response_handlers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   module RPC
     class ClientResponseHandlers

data/lib/railway_ipc/rpc/client/errors/timeout_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class Client
     class TimeoutError < StandardError; end

data/lib/railway_ipc/rpc/concerns/error_adapter_configurable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   module RPC
     module ErrorAdapterConfigurable

data/lib/railway_ipc/rpc/concerns/message_observation_configurable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   module RPC
     module MessageObservationConfigurable

data/lib/railway_ipc/rpc/concerns/publish_location_configurable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   module RPC
     module PublishLocationConfigurable

data/lib/railway_ipc/rpc/rpc.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'railway_ipc/rpc/client/client'
 require 'railway_ipc/rpc/server/server'

data/lib/railway_ipc/rpc/server/server.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'railway_ipc/rpc/server/server_response_handlers'
 require 'railway_ipc/rpc/concerns/error_adapter_configurable'
 require 'railway_ipc/rpc/concerns/message_observation_configurable'
@@ -12,7 +14,7 @@ module RailwayIpc
       RailwayIpc::RPC::ServerResponseHandlers.instance.register(handler: with, message: message_type)
     end
 
-    def initialize(opts = {automatic_recovery: true}, rabbit_adapter: RailwayIpc::Rabbitmq::Adapter)
+    def initialize(opts={ automatic_recovery: true }, rabbit_adapter: RailwayIpc::Rabbitmq::Adapter)
       @rabbit_connection = rabbit_adapter.new(
         queue_name: self.class.queue_name,
         exchange_name: self.class.exchange_name,
@@ -29,6 +31,8 @@ module RailwayIpc
       subscribe_to_queue
     end
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def work(payload)
       decoded_payload = RailwayIpc::Rabbitmq::Payload.decode(payload)
       case decoded_payload.type
@@ -38,22 +42,35 @@ module RailwayIpc
         responder.respond(message)
       else
         @message = LearnIpc::ErrorMessage.decode(decoded_payload.message)
-        raise RailwayIpc::UnhandledMessageError, "#{self.class} does not know how to handle #{decoded_payload.type}"
+        raise RailwayIpc::UnhandledMessageError.new("#{self.class} does not know how to handle #{decoded_payload.type}")
       end
     rescue StandardError => e
-      RailwayIpc.logger.log_exception(
-        feature: 'railway_consumer',
+      RailwayIpc.logger.error(
+        e.message,
+        feature: 'railway_ipc_consumer',
+        exchange: self.class.exchange_name,
+        queue: self.class.queue_name,
         error: e.class,
-        error_message: e.message,
         payload: payload
       )
       raise e
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def handle_request(payload)
       response = work(payload)
     rescue StandardError => e
-      RailwayIpc.logger.error(message, "Error responding to message. Error: #{e.class}, #{e.message}")
+      RailwayIpc.logger.error(
+        'Error responding to message.',
+        exception: e,
+        feature: 'railway_ipc_consumer',
+        exchange: self.class.exchange_name,
+        queue: self.class.queue_name,
+        protobuf: { type: message.class, data: message }
+      )
       response = self.class.rpc_error_adapter_class.error_message(e, message)
     ensure
       if response
@@ -62,6 +79,8 @@ module RailwayIpc
         )
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
     private
 
@@ -84,6 +103,5 @@ module RailwayIpc
         handle_request(payload)
       end
     end
-
   end
 end

data/lib/railway_ipc/rpc/server/server_response_handlers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'railway_ipc/handler_store'
 module RailwayIpc
   module RPC

data/lib/railway_ipc/tasks/generate_migrations.rake

@@ -1,25 +1,25 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 
 namespace :railway_ipc do
   namespace :generate do
-    desc "Generates migrations to store Railway messages"
+    desc 'Generates migrations to store Railway messages'
     task :migrations do
-      if defined?(ActiveRecord::Base)
-        puts "generating Railway IPC table migrations"
-        seconds = 0
-        gem_path = Gem.loaded_specs['railway-ipc'].full_gem_path
-        folder_dest = "#{Rails.root.to_s}/db/migrate"
-        FileUtils.mkdir_p(folder_dest)
+      raise 'Migration generation requires active record' unless defined?(ActiveRecord::Base)
+
+      puts 'generating Railway IPC table migrations'
+      seconds = 0
+      gem_path = Gem.loaded_specs['railway-ipc'].full_gem_path
+      folder_dest = "#{Rails.root}/db/migrate"
+      FileUtils.mkdir_p(folder_dest)
 
-        Dir.glob("#{gem_path}/priv/migrations/*.rb").each do |file_path|
-          file_name = File.basename(file_path)
-          migration_timestamp = (Time.now + seconds).utc.strftime("%Y%m%d%H%M%S") % "%.14d"
-          new_file_name = "#{migration_timestamp}_#{file_name}"
-          FileUtils.copy_file(file_path, "#{folder_dest}/#{new_file_name}")
-          seconds += 1
-        end
-      else
-        raise "Migration generation requires active record"
+      Dir.glob("#{gem_path}/priv/migrations/*.rb").each do |file_path|
+        file_name = File.basename(file_path)
+        migration_timestamp = (Time.now + seconds).utc.strftime('%Y%m%d%H%M%S') % '%.14d'
+        new_file_name = "#{migration_timestamp}_#{file_name}"
+        FileUtils.copy_file(file_path, "#{folder_dest}/#{new_file_name}")
+        seconds += 1
       end
     end
   end