railway-ipc 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2a31b80fc9d4f13598bdc2fbd14c84c78360bd4adeb588bb63b3bb20c33a2de
-  data.tar.gz: 2bfef85b0fbe56b0d66df365f8ffa5b7913b188658edbb63484aaa0138dfa6ba
+  metadata.gz: 11e49c11ff3e5815f7c8050ad5fcdfde1510cf7646d10cfa5d1104a5c1868422
+  data.tar.gz: 3fbdeab2e555f9c4b3402cf27e3b072d33c833f85659eaccc09f31d11fddc219
 SHA512:
-  metadata.gz: a27c830370df223add103179c9e8b60d5259abbb5b21b664f0b2642d96e5736926325c07e271b08822401c312ef532ec8a6f3c03dba30ce5a637edcbbba1ed12
-  data.tar.gz: 555cb81425239fba2c5752e238bd541db554f48eb7d46d1336122d730781e40fdd0b339a8266a49a42ace8b73909d7a26f145b9e3ea5d9602fbfcefb9db1a022
+  metadata.gz: 70d3834ac2a0db7b1a9a53c52edb3718b34a821d3b0d42e49ebe01f1c76c00188b928734a5969ef621e9609a3852117fd8190706566777c870b2b8b3d9592ccd
+  data.tar.gz: 297bbf2e92f9a77d85661849f3bbada5b18eff08b213ec6a48089dea112ab65b70a47b196e8ddc59b475e61cb9e6ecfc8648bb5dcbcd2836e341079d81b2fd92

data/CHANGELOG.md

@@ -10,6 +10,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Removed
 ### Fixed
 
+## [2.0.0] - 2020-08-20
+### Added
+* Several additions to internal logging:
+  - Log messages now include a `feature` key. This can be used by logging aggregator tools to group log messages across different systems that use the gem. If one isn't provided a default value of `railway_ipc` is used.
+  - Protobufs are logged as a sub-hash which contains both the protobuf type and payload.
+  - Exchange and queue names are logged where applicable.
+  - The internal Bunny connection now uses the `RailwayIpc::Logger` instead of a generic `Logger`.
+
+### Changed
+* *Breaking Change* `RailwayIpc.configure` now takes `device`, `level`, and `formatter` instead of a complete `Logger` instance. The instance is now managed internally by Railway. This is a breaking change to the `RailwayIpc.configure` API, clients will need to be updated to use the new syntax.
+
 ## [1.1.0] - 2020-08-07
 ### Changed
 * allow multiple consumers to handle the same message

data/README.md

@@ -19,7 +19,7 @@ And then execute:
 ```ruby
 # config/initializers/railway_ipc.rb
 
-RailwayIpc.configure(logger: Rails.logger)
+RailwayIpc.configure(STDOUT, Logger::INFO, MyFormatter)
 ```
 
 * Load the rake tasks in your Rakefile

data/lib/railway_ipc.rb

@@ -29,16 +29,12 @@ module RailwayIpc
     Rake::Task['sneakers:run'].invoke
   end
 
-  def self.configure(logger: ::Logger.new(STDOUT))
-    @logger = RailwayIpc::Logger.new(logger)
+  def self.configure(log_device=STDOUT, level=::Logger::INFO, log_formatter=nil)
+    @logger = RailwayIpc::Logger.new(log_device, level, log_formatter)
   end
 
   def self.logger
-    @logger || RailwayIpc::Logger.new(::Logger.new(STDOUT))
-  end
-
-  def self.bunny_logger
-    logger.logger
+    @logger || RailwayIpc::Logger.new(STDOUT)
   end
 
   def self.bunny_connection

data/lib/railway_ipc/consumer/consumer.rb

@@ -44,10 +44,12 @@ module RailwayIpc
       RailwayIpc::ProcessIncomingMessage.call(self, message)
       ack!
     rescue StandardError => e
-      RailwayIpc.logger.log_exception(
-        feature: 'railway_consumer',
+      RailwayIpc.logger.error(
+        e.message,
+        feature: 'railway_ipc_consumer',
+        exchange: exchange_name,
+        queue: queue_name,
         error: e.class,
-        error_message: e.message,
         payload: payload
       )
       raise e

data/lib/railway_ipc/consumer/process_incoming_message.rb

@@ -16,8 +16,9 @@ module RailwayIpc
 
       def run
         logger.warn(
-          incoming_message.decoded,
-          "Ignoring unknown message of type '#{incoming_message.type}'"
+          "Ignoring unknown message of type '#{incoming_message.type}'",
+          feature: 'railway_ipc_consumer',
+          protobuf: { type: incoming_message.type, data: incoming_message.decoded }
         )
       end
     end
@@ -36,8 +37,9 @@ module RailwayIpc
 
       def run
         logger.warn(
-          incoming_message.decoded,
-          "Ignoring message, no registered handler for '#{incoming_message.type}'"
+          "Ignoring message, no registered handler for '#{incoming_message.type}'",
+          feature: 'railway_ipc_consumer',
+          protobuf: { type: incoming_message.type, data: incoming_message.decoded }
         )
       end
     end
@@ -81,7 +83,13 @@ module RailwayIpc
 
     def raise_message_invalid_error
       error = "Message is invalid: #{incoming_message.stringify_errors}."
-      logger.error(incoming_message.decoded, error)
+      logger.error(
+        error,
+        feature: 'railway_ipc_consumer',
+        exchange: consumer.exchange_name,
+        queue: consumer.queue_name,
+        protobuf: { type: incoming_message.class, data: incoming_message.decoded }
+      )
       raise RailwayIpc::IncomingMessage::InvalidMessage.new(error)
     end
 

data/lib/railway_ipc/handler.rb

@@ -11,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/logger.rb

@@ -1,36 +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
-    end
-
-    def info(message, statement)
-      logger.info("[#{message_header(message)}] #{statement}")
+    def initialize(device=STDOUT, level=::Logger::INFO, formatter=nil)
+      @logger = ::Logger.new(device)
+      @logger.level = level
+      @logger.formatter = formatter if formatter
     end
 
-    def warn(message, statement)
-      logger.warn("[#{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 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(exception)
-      logger.error(exception)
-    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/publisher.rb

@@ -21,16 +21,15 @@ module RailwayIpc
     end
 
     def publish(message, published_message_store=RailwayIpc::PublishedMessage)
-      RailwayIpc.logger.logger.warn('DEPRECATED: Use new PublisherInstance class')
+      RailwayIpc.logger.warn('DEPRECATED: Use new PublisherInstance class', log_message_options)
       ensure_message_uuid(message)
       ensure_correlation_id(message)
-      RailwayIpc.logger.info(message, 'Publishing 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
 
@@ -45,6 +44,11 @@ module RailwayIpc
       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
 
@@ -68,20 +72,33 @@ module RailwayIpc
     def publish(message)
       message.uuid = SecureRandom.uuid if message.uuid.blank?
       message.correlation_id = SecureRandom.uuid if message.correlation_id.blank?
-      RailwayIpc.logger.info(message, 'Publishing message')
+      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(message, 'Invalid protobuf')
+      RailwayIpc.logger.error('Invalid protobuf', log_message_options(message))
       raise e
     rescue ActiveRecord::RecordInvalid => e
-      RailwayIpc.logger.error(message, 'Failed to store outgoing message')
+      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

@@ -28,7 +28,7 @@ module RailwayIpc
           port: settings[:port],
           vhost: vhost,
           automatic_recovery: false,
-          logger: RailwayIpc.bunny_logger
+          logger: RailwayIpc.logger
         }.merge(options))
       end
 

data/lib/railway_ipc/responder.rb

@@ -11,7 +11,11 @@ module RailwayIpc
     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)
 

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

@@ -39,18 +39,26 @@ module RailwayIpc
     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.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
@@ -78,10 +86,12 @@ module RailwayIpc
     private
 
     def log_exception(exception, payload)
-      RailwayIpc.logger.log_exception(
-        feature: 'railway_consumer',
+      RailwayIpc.logger.error(
+        exception.message,
+        feature: 'railway_ipc_consumer',
+        exchange: self.class.exchange_name,
+        queue: self.class.queue_name,
         error: exception.class,
-        error_message: exception.message,
         payload: decode_for_error(exception, payload)
       )
     end
@@ -99,7 +109,12 @@ module RailwayIpc
     end
 
     def publish_message
-      RailwayIpc.logger.info(request_message, 'Sending request')
+      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
 

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

@@ -45,10 +45,12 @@ module RailwayIpc
         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
@@ -56,10 +58,19 @@ module RailwayIpc
     # 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
@@ -68,6 +79,8 @@ module RailwayIpc
         )
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
     private
 

data/lib/railway_ipc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailwayIpc
-  VERSION = '1.1.0'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: railway-ipc
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - ''
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-07 00:00:00.000000000 Z
+date: 2020-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -263,7 +263,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org/
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -278,9 +278,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
+rubyforge_project:
 rubygems_version: 2.7.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: IPC components for Rails
 test_files: []