dispatch-rider 1.6.1 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20ecab8e18af62e4795b431f0860148f5929277c
-  data.tar.gz: b87e0c608b4ee99a1e85279bf9d42afc5b4e8b53
+  metadata.gz: 697069b0aff03bae879decd081323fe5c90441b1
+  data.tar.gz: 25ae5e9c896c920864800e9dea6e7421cafe3aee
 SHA512:
-  metadata.gz: 9e645f3c4257d14f8d17e1402ec5ef73ceee737b380ffa531391a010ad28e11fba30baa806af34d1d21f518583fd6bc44651fc65e5bc36a7f698f50c4edc1158
-  data.tar.gz: 8aa77e404a4caa1680def056db848c6c124c1e1ee935278770b9a35c8e278100a23c5b347b80c2bdadc5c62c3e2b8a494b8f2f5850af531abc46299b824811ea
+  metadata.gz: a0496f4be0ffffa3bcf025abc4a92dd8fc42c621a667bf8c69841120a8472cf0c37f37663b2fc0226b59b7e01990219eb8eec528fcb851974f0848eb4f6af445
+  data.tar.gz: 407419063fd8c30148d644156ddbaba8342250f9310dc6323d5affa259ec15dcf2ba9694893d209530f978ff7fb5cee5c21551b8d00652c71584fbcc47b8a3b8

data/Gemfile

@@ -15,6 +15,7 @@ gem 'yard'
 
 # Testing
 gem "rspec", "~> 3.3"
+gem "factory_girl"
 
 # CI
 gem "travis-lint"

data/lib/dispatch-rider/configuration.rb

@@ -1,6 +1,16 @@
 module DispatchRider
   class Configuration
-    attr_accessor :handler_path, :error_handler, :queue_info, :queue_kind, :subscriber, :logger, :log_formatter, :debug
+    attr_accessor(
+      :handler_path,
+      :error_handler,
+      :queue_info,
+      :queue_kind,
+      :subscriber,
+      :logger,
+      :log_formatter,
+      :debug,
+      :additional_info_injector
+    )
     attr_reader :callbacks
 
     def initialize
@@ -11,6 +21,7 @@ module DispatchRider
       @callbacks = Callbacks::Storage.new
       @subscriber = DispatchRider::Subscriber
       @log_formatter = DispatchRider::Logging::TextFormatter.new
+      @additional_info_injector = -> (data) { data }
       @logger = Logger.new(STDERR)
       @debug = false
 

data/lib/dispatch-rider/logging.rb

@@ -4,7 +4,7 @@ module DispatchRider
   end
 end
 
+require_relative 'logging/translator'
 require_relative 'logging/lifecycle_logger'
-require_relative 'logging/base_formatter'
 require_relative 'logging/text_formatter'
 require_relative 'logging/json_formatter'

data/lib/dispatch-rider/logging/json_formatter.rb

@@ -3,79 +3,12 @@ require 'json'
 # JSON Log Formatter
 module DispatchRider
   module Logging
-    class JsonFormatter < BaseFormatter
-      # @param [DispatchRider::QueueServices::ReceivedMessage] message
-      # @param [Exception] exception
-      # @return [String] JSON representation of the log item
-      def format_error_handler_fail(message, exception)
-        as_json do
-          {
-            phase: :failed,
-          }.merge exception_info_fragment(message, exception)
-        end
-      end
-
-      # @param [DispatchRider::QueueServices::ReceivedMessage] message
-      # @param [String] reason
-      # @return [String] JSON representation of the log item
-      def format_got_stop(message, reason)
-        as_json do
-          {
-            phase: :stop,
-            reason: reason,
-          }.merge message_info_fragment(message)
-        end
-      end
-
-      # @param [Symbol] kind of log action. one of: :start, :success, :fail, :complete
-      # @param [DispatchRider::QueueServices::ReceivedMessage] message
-      # @param [Exception] exception
-      # @param [Float] Job execution duration
-      # @return [String] JSON representation of the log item
-      def format_handling(kind, message, exception: nil, duration: nil)
-        as_json do
-          fragment = case kind
-                     when :start
-                       message_info_fragment(message)
-                     when :success
-                       message_info_fragment(message)
-                     when :fail
-                       exception_info_fragment(message, exception)
-                     when :complete
-                       duration_fragment = { duration: format_duration(duration) }
-                       message_info_fragment(message).merge duration_fragment
-                     end
-          { phase: kind }.merge fragment
-        end
-      end
-
-      private
+    class JsonFormatter
 
-      def format_duration(duration)
-        duration
+      def format(data)
+        data.to_json
       end
 
-      def as_json
-        JSON.generate yield
-      end
-
-      def message_info_fragment(message)
-        {
-          guid: message.guid.to_s,
-          subject: message.subject,
-          body: message_info_arguments(message),
-        }
-      end
-
-      def exception_info_fragment(message, exception)
-        exception_details = {
-          expection: {
-            class: exception.class.to_s,
-            message: exception.message,
-          }
-        }
-        message_info_fragment(message).merge exception_details
-      end
     end
   end
 end

data/lib/dispatch-rider/logging/lifecycle_logger.rb

@@ -3,11 +3,11 @@ module DispatchRider
     class LifecycleLogger
       class << self
         def log_error_handler_fail(message, exception)
-          logger.error formatter.format_error_handler_fail(message, exception)
+          new(:error_handler_fail, message, exception: exception).log
         end
 
         def log_got_stop(reason, message)
-          logger.info formatter.format_got_stop(message, reason)
+          new(:stop, message, reason: reason).log
         end
 
         def wrap_handling(message)
@@ -25,29 +25,71 @@ module DispatchRider
         private
 
         def log_complete(message, duration)
-          logger.info formatter.format_handling :complete, message, duration: duration
+          new(:complete, message, duration: duration).log
         end
 
         def log_fail(message, exception)
-          logger.error formatter.format_handling :fail, message, exception: exception
+          new(:fail, message, exception: exception).log
         end
 
         def log_success(message)
-          logger.info formatter.format_handling :success, message
+          new(:success, message).log
         end
 
         def log_start(message)
-          logger.info formatter.format_handling :start, message
+          new(:start, message).log
         end
+      end
 
-        def formatter
-          DispatchRider.config.log_formatter
-        end
+      def initialize(kind, message, options = {})
+        @kind = kind
+        @message = message
+        @options = options
+      end
+
+      def log
+        logger.send(log_action, formatted_data)
+      end
+
+      private
+
+      attr_reader :kind, :message, :options
+
+      def formatter
+        DispatchRider.config.log_formatter
+      end
+
+      def logger
+        DispatchRider.config.logger
+      end
 
-        def logger
-          DispatchRider.config.logger
+      def additional_info_injector
+        DispatchRider.config.additional_info_injector
+      end
+
+      def translator
+        Translator
+      end
+
+      def translated_message
+        translator.translate(message, kind, options)
+      end
+
+      def interjected_message
+        additional_info_injector.call(translated_message)
+      end
+
+      def formatted_data
+        formatter.format(interjected_message)
+      end
+
+      def log_action
+        case kind
+        when :fail, :error_handler_fail then :error
+        when :start, :stop, :complete, :success then :info
         end
       end
+
     end
   end
 end

data/lib/dispatch-rider/logging/text_formatter.rb

@@ -1,48 +1,48 @@
 # Text Log Formatter
 module DispatchRider
   module Logging
-    class TextFormatter < BaseFormatter
-      # @param [DispatchRider::QueueServices::ReceivedMessage] message
-      # @param [Exception] exception
-      # @return [String] log item
-      def format_error_handler_fail(message, exception)
-        "Failed error handling of: #{exception_info_fragment(message, exception)}"
-      end
-
-      # @param [DispatchRider::QueueServices::ReceivedMessage] message
-      # @param [String] reason
-      # @return [String] log item
-      def format_got_stop(message, reason)
-        "Got stop #{reason ? '(' + reason + ') ' : ' ' }while executing: #{message_info_fragment(message)}"
-      end
+    class TextFormatter
 
-      # @param [Symbol] kind of log action. one of: :start, :success, :fail, :complete
-      # @param [DispatchRider::QueueServices::ReceivedMessage] message
-      # @param [Exception] exception
-      # @param [Float] Job execution duration
-      # @return [String] log item
-      def format_handling(kind, message, exception: nil, duration: nil)
-        case kind
+      def format(data)
+        case data[:phase]
+        when :complete
+          "Completed execution of: #{message_info_fragment(data)} in #{format_duration(data[:duration])} seconds"
+        when :fail
+          "Failed execution of: #{exception_info_fragment(data)}"
         when :start
-          "Starting execution of: #{message_info_fragment(message)}"
+          "Starting execution of: #{message_info_fragment(data)}"
         when :success
-          "Succeeded execution of: #{message_info_fragment(message)}"
-        when :fail
-          "Failed execution of: #{exception_info_fragment(message, exception)}"
-        when :complete
-          "Completed execution of: #{message_info_fragment(message)} in #{format_duration(duration)} seconds"
+          "Succeeded execution of: #{message_info_fragment(data)}"
+        when :stop
+          "Got stop #{data[:reason] ? '(' + data[:reason] + ')' : '' } while executing: #{message_info_fragment(data)}"
+        when :error_handler_fail
+          "Failed error handling of: #{exception_info_fragment(data)}"
+        else
+          raise ArgumentError, "Invalid phase : #{data[:phase].inspect}"
         end
       end
 
       private
 
-      def message_info_fragment(message)
-        "(#{message.guid}): #{message.subject} : #{message_info_arguments(message).inspect}"
+      def message_info_fragment(data)
+        "(#{data[:guid]}): #{data[:subject]} : #{message_info_arguments(data[:body]).inspect}"
       end
 
-      def exception_info_fragment(message, exception)
-        "(#{message.guid}): #{message.subject} with #{exception.class}: #{exception.message}"
+      def exception_info_fragment(data)
+        "(#{data[:guid]}): #{data[:subject]} with #{data[:exception][:class]}: #{data[:exception][:message]}"
       end
+
+      def message_info_arguments(body)
+        body.dup.tap do |m|
+          m.delete('guid')
+          m.delete('object_id')
+        end
+      end
+
+      def format_duration(duration)
+        '%.2f' % [duration]
+      end
+
     end
   end
 end

data/lib/dispatch-rider/logging/translator.rb

@@ -0,0 +1,26 @@
+module DispatchRider
+  module Logging
+
+    # Translates a message into a loggable hash based on its result.
+    class Translator
+      def self.translate(message, kind, **args)
+        klass = translator_class(kind)
+        fragment = klass.new(message, **args).translate
+        { phase: kind }.merge fragment
+      end
+
+      def self.translator_class(kind)
+        const_get("#{kind}_translator".classify)
+      end
+    end
+
+  end
+end
+
+require_relative 'translator/base_translator'
+require_relative 'translator/complete_translator'
+require_relative 'translator/fail_translator'
+require_relative 'translator/error_handler_fail_translator'
+require_relative 'translator/start_translator'
+require_relative 'translator/stop_translator'
+require_relative 'translator/success_translator'

data/lib/dispatch-rider/logging/translator/base_translator.rb

@@ -0,0 +1,44 @@
+module DispatchRider
+  module Logging
+    class Translator
+
+      class BaseTranslator
+        def initialize(message, **)
+          @message = message
+        end
+
+        def translate
+          raise NotImplementedError, 'Translators must implement #translate'
+        end
+
+        private
+
+        def message_info_fragment(message)
+          {
+            guid: message.guid.to_s,
+            subject: message.subject,
+            body: message_info_arguments(message),
+          }
+        end
+
+        def message_info_arguments(message)
+          message.body.dup.tap do |m|
+            m.delete('guid')
+            m.delete('object_id')
+          end
+        end
+
+        def exception_info_fragment(message, exception)
+          exception_details = {
+            exception: {
+              class: exception.class.to_s,
+              message: exception.message,
+            }
+          }
+          message_info_fragment(message).merge exception_details
+        end
+      end
+
+    end
+  end
+end

data/lib/dispatch-rider/logging/translator/complete_translator.rb

@@ -0,0 +1,18 @@
+module DispatchRider
+  module Logging
+    class Translator
+
+      class CompleteTranslator < BaseTranslator
+        def initialize(message, duration:)
+          super(message)
+          @duration = duration
+        end
+
+        def translate
+          message_info_fragment(@message).merge duration: @duration
+        end
+      end
+
+    end
+  end
+end

data/lib/dispatch-rider/logging/translator/error_handler_fail_translator.rb

@@ -0,0 +1,10 @@
+module DispatchRider
+  module Logging
+    class Translator
+
+      class ErrorHandlerFailTranslator < FailTranslator
+      end
+
+    end
+  end
+end

data/lib/dispatch-rider/logging/translator/fail_translator.rb

@@ -0,0 +1,18 @@
+module DispatchRider
+  module Logging
+    class Translator
+
+      class FailTranslator < BaseTranslator
+        def initialize(message, exception:)
+          super(message)
+          @exception = exception
+        end
+
+        def translate
+          exception_info_fragment(@message, @exception)
+        end
+      end
+
+    end
+  end
+end

data/lib/dispatch-rider/logging/translator/start_translator.rb

@@ -0,0 +1,13 @@
+module DispatchRider
+  module Logging
+    class Translator
+
+      class StartTranslator < BaseTranslator
+        def translate
+          message_info_fragment(@message)
+        end
+      end
+
+    end
+  end
+end

data/lib/dispatch-rider/logging/translator/stop_translator.rb

@@ -0,0 +1,18 @@
+module DispatchRider
+  module Logging
+    class Translator
+
+      class StopTranslator < BaseTranslator
+        def initialize(message, reason:)
+          super(message)
+          @reason = reason
+        end
+
+        def translate
+          message_info_fragment(@message).merge reason: @reason
+        end
+      end
+
+    end
+  end
+end

data/lib/dispatch-rider/logging/translator/success_translator.rb

@@ -0,0 +1,10 @@
+module DispatchRider
+  module Logging
+    class Translator
+
+      class SuccessTranslator < StartTranslator
+      end
+
+    end
+  end
+end

data/lib/dispatch-rider/version.rb

@@ -1,4 +1,4 @@
 # This file specifies the current version of the gem.
 module DispatchRider
-  VERSION = "1.6.1"
+  VERSION = "1.6.2"
 end

data/spec/factories/messages.rb

@@ -0,0 +1,10 @@
+FactoryGirl.define do
+  factory :message, class: 'DispatchRider::Message' do
+    subject 'sample_handler'
+    body(
+      'key' => 'value',
+      'guid' => DispatchRider::Debug::PUBLISHER_MESSAGE_GUID,
+    )
+    initialize_with {  DispatchRider::Message.new(attributes) }
+  end
+end

data/spec/integration/logging_spec.rb

@@ -97,7 +97,7 @@ describe "Logging" do
         'guid' => 'test-mode-not-random-guid',
         'subject' => 'crashing_handler',
         'body' => {},
-        'expection' => {
+        'exception' => {
           'class' => 'RuntimeError',
           'message' => 'I crashed!',
         },

data/spec/lib/dispatch-rider/logging/json_formatter_spec.rb

@@ -1,72 +1,11 @@
 require 'spec_helper'
 
 describe DispatchRider::Logging::JsonFormatter do
-  let(:fs_message) { DispatchRider::Message.new(subject: 'test', body: { 'key' => 'value', 'guid' => 123 }) }
-  let(:item) { double :item }
-  let(:queue) { double :queue }
-  let(:message) { DispatchRider::QueueServices::FileSystem::FsReceivedMessage.new(fs_message, item, queue) }
-  let(:exception) { StandardError.new }
-  let(:reason) { "Stop reason" }
+  let(:data) { { some: :data } }
 
-  let(:result_object) do
-    {
-      "subject" => "test",
-      "guid" => "123",
-      "body" => {
-        "key" => "value"
-      },
-    }
-  end
-  let(:result_exception) do
-    {
-      "expection" => {
-        "class" => "StandardError",
-        "message" => "StandardError"
-      }
-    }
-  end
-
-  context "format_error_handler_fail" do
-    let(:formatted_message) { result_object.merge("phase" => "failed").merge(result_exception) }
-    let(:result_message) { JSON.parse subject.format_error_handler_fail(message, exception) }
-
-    example { expect(result_message).to eq(formatted_message) }
-  end
-
-  context "format_got_stop" do
-    let(:formatted_message) { result_object.merge("phase" => "stop", "reason" => reason) }
-    let(:result_message) { JSON.parse subject.format_got_stop(message, reason) }
-
-    example { expect(result_message).to eq(formatted_message) }
-  end
-
-  context "format_handling" do
-    context "start" do
-      let(:formatted_message) { result_object.merge("phase" => "start") }
-      let(:result_message) { JSON.parse subject.format_handling(:start, message) }
-
-      example { expect(result_message).to eq(formatted_message) }
-    end
-
-    context "success" do
-      let(:formatted_message) { result_object.merge("phase" => "success") }
-      let(:result_message) { JSON.parse subject.format_handling(:success, message) }
-
-      example { expect(result_message).to eq(formatted_message) }
-    end
-
-    context "complete" do
-      let(:formatted_message) { result_object.merge("phase" => "complete", "duration" => 2.0) }
-      let(:result_message) { JSON.parse subject.format_handling(:complete, message, duration: 2.0) }
-
-      example { expect(result_message).to eq(formatted_message) }
-    end
-
-    context "fail" do
-      let(:formatted_message) { result_object.merge("phase" => "fail").merge(result_exception) }
-      let(:result_message) { JSON.parse subject.format_handling(:fail, message, exception: exception) }
+  let(:formatted_data) { %{{"some":"data"}} }
 
-      example { expect(formatted_message).to eq(formatted_message) }
-    end
+  example do
+    expect(described_class.new.format(data)).to eq(formatted_data)
   end
 end

data/spec/lib/dispatch-rider/logging/lifecycle_logger_spec.rb

@@ -1,72 +1,168 @@
 require 'spec_helper'
 
-describe DispatchRider::Logging::LifecycleLogger do
+describe DispatchRider::Logging::LifecycleLogger, aggregrate_failures: true do
   subject { DispatchRider::Logging::LifecycleLogger }
 
-  let(:message) { DispatchRider::Message.new(subject: 'test', body: 'test_handler') }
-  let(:string_to_log) { "string to log" }
-  let(:exception) { StandardError.new }
+  let(:queue) { double :queue }
+  let(:item) { double :item }
+  let(:fs_message) { DispatchRider::QueueServices::FileSystem::FsReceivedMessage.new(message, item, queue) }
+  let(:message) { DispatchRider::Message.new(subject: 'test', body: { 'guid' => '123', 'some' => 'key' }) }
+  let(:exception) { StandardError.new('something failed') }
   let(:reason) { "Stop reason" }
 
   let(:formatter) { DispatchRider.config.log_formatter }
-  let(:logger) { DispatchRider.config.logger }
+  let(:logger) { double :logger }
 
   before do
-    allow(formatter).to receive(:format_got_stop).and_return(string_to_log)
-    allow(formatter).to receive(:format_error_handler_fail).and_return(string_to_log)
-    allow(formatter).to receive(:format_handling).and_return(string_to_log)
+    DispatchRider.config.logger = logger
   end
 
-  context "log_error_handler_fail" do
-    after { subject.log_error_handler_fail message, exception }
-
-    it "calls logger with error" do
-      expect(logger).to receive(:error).with(string_to_log)
-    end
+  after do
+    DispatchRider.clear_configuration!
   end
 
-  context "log_got_stop" do
-    after { subject.log_got_stop reason, message }
+  context 'when log formatter is json' do
+    before { DispatchRider.config.log_formatter = DispatchRider::Logging::JsonFormatter.new }
 
-    it "calls logger with info" do
-      expect(logger).to receive(:info).with(string_to_log)
-    end
-  end
+    context 'when additional_info_injector is customized' do
+      let(:additional_info_injector) do
+        -> (message) do
+          message[:employee_id] = 47
+          message[:account_id] = 42
+          message
+        end
+      end
 
-  context "wrap_handling" do
-    context "block runs successfully" do
-      let(:block) { Proc.new { true } }
-      after { subject.wrap_handling(message, &block) }
+      before do
+        DispatchRider.config.additional_info_injector = additional_info_injector
+      end
 
-      it "logs start" do
-        expect(subject).to receive(:log_start).with(message)
+      describe 'log_error_handler_fail' do
+        let(:expected_info) do
+          {
+            phase: 'error_handler_fail',
+            guid: '123',
+            subject: 'test',
+            body: { some: 'key' },
+            exception: { class: 'StandardError', message: 'something failed' },
+            employee_id: 47,
+            account_id: 42,
+          }.deep_stringify_keys.to_json
+        end
+
+        it "calls logger with error" do
+          expect(logger).to receive(:error).with(expected_info)
+          subject.log_error_handler_fail fs_message, exception
+        end
       end
 
-      it "logs success" do
-        expect(subject).to receive(:log_success).with(message)
+      describe "log_got_stop" do
+        let(:expected_info) do
+          {
+            phase: 'stop',
+            guid: '123',
+            subject: 'test',
+            body: { some: 'key' },
+            reason: reason,
+            employee_id: 47,
+            account_id: 42,
+          }.deep_stringify_keys.to_json
+        end
+
+        it "calls logger with info" do
+          expect(logger).to receive(:info).with(expected_info)
+          subject.log_got_stop reason, fs_message
+        end
       end
 
-      it "logs complete" do
-        expect(subject).to receive(:log_complete).with(message, an_instance_of(Float))
+      describe "wrap_handling" do
+        let(:expected_start_info) do
+          {
+            phase: 'start',
+            guid: '123',
+            subject: 'test',
+            body: { some: 'key' },
+            employee_id: 47,
+            account_id: 42,
+          }.deep_stringify_keys.to_json
+        end
+
+        let(:expected_succeed_info) do
+          {
+            phase: 'success',
+            guid: '123',
+            subject: 'test',
+            body: { some: 'key' },
+            employee_id: 47,
+            account_id: 42,
+          }.deep_stringify_keys.to_json
+        end
+
+        let(:expected_complete_info) do
+          /{"phase":"complete","guid":"123","subject":"test","body":{"some":"key"},"duration":\d+(?:.\d+)?,"employee_id":47,"account_id":42}/
+        end
+
+        context 'succeeding the handler' do
+          example do
+            expect(logger).to receive(:info).with(expected_start_info)
+            expect(logger).to receive(:info).with(expected_succeed_info)
+            expect(logger).to receive(:info).with(expected_complete_info)
+            expect {
+              subject.wrap_handling(fs_message) { true }
+            }.not_to raise_exception
+          end
+        end
       end
     end
 
-    context "block fails" do
-      let(:block) { Proc.new { raise exception } }
-      after do
-        expect { subject.wrap_handling(message, &block) }.to raise_error(exception)
+    context 'when log formatter is text based' do
+      before do
+        DispatchRider.config.log_formatter = DispatchRider::Logging::TextFormatter.new
       end
 
-      it "logs start" do
-        expect(subject).to receive(:log_start).with(message)
+      describe "log_error_handler_fail" do
+        it "calls logger with error" do
+          expect(logger).to receive(:error).with(
+            "Failed error handling of: (123): test with StandardError: something failed"
+          )
+          subject.log_error_handler_fail fs_message, exception
+        end
       end
 
-      it "logs fail" do
-        expect(subject).to receive(:log_fail).with(message, exception)
+      describe "log_got_stop" do
+        it "calls logger with info" do
+          expect(logger).to receive(:info).with(
+            %{Got stop (Stop reason) while executing: (123): test : {"some"=>"key"}})
+          subject.log_got_stop reason, fs_message
+        end
       end
 
-      it "logs complete" do
-        expect(subject).to receive(:log_complete).with(message, an_instance_of(Float))
+      describe "wrap_handling" do
+        context 'succeeding the handler' do
+          example do
+            expect(logger).to receive(:info).with(%{Starting execution of: (123): test : {"some"=>"key"}})
+            expect(logger).to receive(:info).with(%{Succeeded execution of: (123): test : {"some"=>"key"}})
+            expect(logger).to receive(:info).with(
+              /Completed execution of: \(123\): test : {"some"=>"key"} in \d+(?:.\d+)? seconds/
+            )
+            expect {
+              subject.wrap_handling(fs_message) { true }
+            }.not_to raise_exception
+          end
+        end
+
+        context 'failing the handler' do
+          example do
+            expect(logger).to receive(:info).with(%{Starting execution of: (123): test : {"some"=>"key"}})
+            expect(logger).to receive(:error).with(%{Failed execution of: (123): test with RuntimeError: failed!})
+            expect(logger).to receive(:info).with(
+              /Completed execution of: \(123\): test : {"some"=>"key"} in \d+(?:.\d+)? seconds/
+            )
+            expect {
+              subject.wrap_handling(fs_message) { raise "failed!" }
+            }.to raise_exception "failed!"
+          end
+        end
       end
     end
   end

data/spec/lib/dispatch-rider/logging/text_formatter_spec.rb

@@ -1,60 +1,73 @@
 require 'spec_helper'
 
 describe DispatchRider::Logging::TextFormatter do
-  let(:fs_message) { DispatchRider::Message.new(subject: 'test', body: { 'key' => 'value', 'guid' => 123 }) }
-  let(:item) { double :item }
-  let(:queue) { double :queue }
-  let(:message) { DispatchRider::QueueServices::FileSystem::FsReceivedMessage.new(fs_message, item, queue) }
-
-  let(:string_to_log) { "string to log" }
-  let(:exception) { StandardError.new }
-  let(:reason) { "Stop reason" }
-
-  before do
-    allow(subject).to receive(:message_info_fragment).and_return(string_to_log)
-    allow(subject).to receive(:exception_info_fragment).and_return(string_to_log)
-  end
+  describe "#format" do
+    subject(:format_result) { described_class.new.format(data) }
 
-  context "format_error_handler_fail" do
-    let(:formatted_message) { "Failed error handling of: string to log" }
-    example do
-      expect(subject.format_error_handler_fail(message, exception)).to eq(formatted_message)
+    let(:data) do
+      {
+        phase: phase,
+        guid: '123',
+        body: { foo: :bar },
+        subject: 'sample_handler',
+      }
     end
-  end
 
-  context "format_got_stop" do
-    let(:formatted_message) { "Got stop (Stop reason) while executing: string to log" }
-    example do
-      expect(subject.format_got_stop(message, reason)).to eq(formatted_message)
+    context 'when phase is :complete' do
+      let(:phase) { :complete }
+
+      before { data[:duration] = 10 }
+
+      example do
+        expect(format_result).to eq("Completed execution of: (123): sample_handler : {:foo=>:bar} in 10.00 seconds")
+      end
     end
-  end
 
-  context "format_handling" do
-    context "start" do
-      let(:formatted_message) { "Starting execution of: string to log" }
+    context 'when phase is :fail' do
+      let(:phase) { :fail }
+
+      before { data[:exception] = { class: StandardError, message: 'Foo is not bar' } }
+
       example do
-        expect(subject.format_handling(:start, message)).to eq(formatted_message)
+        expect(format_result).to eq("Failed execution of: (123): sample_handler with StandardError: Foo is not bar")
       end
     end
 
-    context "success" do
-      let(:formatted_message) { "Succeeded execution of: string to log" }
+    context 'when phase is :start' do
+      let(:phase) { :start }
+
       example do
-        expect(subject.format_handling(:success, message)).to eq(formatted_message)
+        expect(format_result).to eq("Starting execution of: (123): sample_handler : {:foo=>:bar}")
       end
     end
 
-    context "complete" do
-      let(:formatted_message) { "Completed execution of: string to log in 2.12 seconds" }
+    context 'when phase is :success' do
+      let(:phase) { :success }
+
       example do
-        expect(subject.format_handling(:complete, message, duration: 2.12)).to eq(formatted_message)
+        expect(format_result).to eq("Succeeded execution of: (123): sample_handler : {:foo=>:bar}")
       end
     end
 
-    context "fail" do
-      let(:formatted_message) { "Failed execution of: string to log" }
+    context 'when phase is :stop' do
+      let(:phase) { :stop }
+
+      before { data[:reason] = 'Ninja Attack' }
+
+      example do
+        expect(format_result).to eq("Got stop (Ninja Attack) while executing: (123): sample_handler : {:foo=>:bar}")
+      end
+    end
+
+    context 'when phase is :error_handler_fail' do
+      let(:phase) { :error_handler_fail }
+
+      before { data[:exception] = { class: StandardError, message: 'Foo is not bar' } }
+
       example do
-        expect(subject.format_handling(:fail, message, exception: exception)).to eq(formatted_message)
+        expect(format_result).to eq(
+          "Failed error handling of: (123): sample_handler with StandardError: Foo is not bar"
+        )
       end
     end
   end

data/spec/lib/dispatch-rider/logging/translator_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe DispatchRider::Logging::Translator do
+  let(:queue) { double :queue }
+  let(:message) { build(:message) }
+  let(:item) { double :item }
+  let(:fs_message) { DispatchRider::QueueServices::FileSystem::FsReceivedMessage.new(message, item, queue) }
+
+  let(:exception) { nil }
+  let(:duration) { nil }
+  let(:reason) { nil }
+
+  describe '.translate' do
+    context 'when the job is starting' do
+      subject(:result) do
+        described_class.translate(fs_message, kind)
+      end
+      let(:kind) { :start }
+      let(:expected_hash) do
+        {
+          phase: :start,
+          subject: 'sample_handler',
+          guid: DispatchRider::Debug::PUBLISHER_MESSAGE_GUID,
+          body: {
+            'key' => 'value',
+          },
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_hash)
+      end
+    end
+
+    context 'when the job has succeeded' do
+      subject(:result) do
+        described_class.translate(fs_message, kind)
+      end
+      let(:kind) { :success }
+      let(:expected_hash) do
+        {
+          phase: :success,
+          subject: 'sample_handler',
+          guid: DispatchRider::Debug::PUBLISHER_MESSAGE_GUID,
+          body: {
+            'key' => 'value',
+          },
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_hash)
+      end
+    end
+
+    context 'when the job has failed' do
+      subject(:result) do
+        described_class.translate(fs_message, kind, exception: exception)
+      end
+      let(:kind) { :fail }
+      let(:exception) do
+        ArgumentError.new("Foo is not bar")
+      end
+
+      let(:expected_hash) do
+        {
+          phase: :fail,
+          subject: 'sample_handler',
+          guid: DispatchRider::Debug::PUBLISHER_MESSAGE_GUID,
+          body: {
+            'key' => 'value',
+          },
+          exception: {
+            class: 'ArgumentError',
+            message: 'Foo is not bar',
+          }
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_hash)
+      end
+    end
+
+    context 'when the job has completed' do
+      subject(:result) do
+        described_class.translate(fs_message, kind, duration: duration)
+      end
+      let(:kind) { :complete }
+      let(:duration) { 5 }
+      let(:expected_hash) do
+        {
+          phase: :complete,
+          subject: 'sample_handler',
+          guid: DispatchRider::Debug::PUBLISHER_MESSAGE_GUID,
+          body: {
+            'key' => 'value',
+          },
+          duration: 5,
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_hash)
+      end
+    end
+
+    context 'when the error handler fails' do
+      subject(:result) do
+        described_class.translate(fs_message, kind, exception: exception)
+      end
+      let(:kind) { :error_handler_fail }
+      let(:exception) do
+        ArgumentError.new("Foo is not bar")
+      end
+
+      let(:expected_hash) do
+        {
+          phase: :error_handler_fail,
+          subject: 'sample_handler',
+          guid: DispatchRider::Debug::PUBLISHER_MESSAGE_GUID,
+          body: {
+            'key' => 'value',
+          },
+          exception: {
+            class: 'ArgumentError',
+            message: 'Foo is not bar',
+          }
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_hash)
+      end
+    end
+
+    context 'when the job has completed' do
+      subject(:result) do
+        described_class.translate(fs_message, kind, reason: reason)
+      end
+      let(:kind) { :stop }
+      let(:reason) { "Got TERM" }
+      let(:expected_hash) do
+        {
+          phase: :stop,
+          subject: 'sample_handler',
+          guid: DispatchRider::Debug::PUBLISHER_MESSAGE_GUID,
+          body: {
+            'key' => 'value',
+          },
+          reason: 'Got TERM',
+        }
+      end
+
+      example do
+        expect(result).to eq(expected_hash)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -10,6 +10,9 @@ require 'tempfile'
 require 'dispatch-rider'
 Dir['./spec/support/**/*.rb'].each { |fn| require(fn) }
 
+FactoryGirl.definition_file_paths = %w{spec/factories/}
+FactoryGirl.find_definitions
+
 RSpec.configure do |config|
   config.raise_errors_for_deprecations!
   config.mock_with :rspec
@@ -25,6 +28,8 @@ RSpec.configure do |config|
   config.before do
     DispatchRider.config.logger = NullLogger.new
   end
+
+  config.include FactoryGirl::Syntax::Methods
 end
 
 # Airbrake dummy module

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dispatch-rider
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.6.2
 platform: ruby
 authors:
 - Suman Mukherjee
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-24 00:00:00.000000000 Z
+date: 2015-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -115,10 +115,17 @@ files:
 - lib/dispatch-rider/handlers/named_process.rb
 - lib/dispatch-rider/integrations/appsignal.rb
 - lib/dispatch-rider/logging.rb
-- lib/dispatch-rider/logging/base_formatter.rb
 - lib/dispatch-rider/logging/json_formatter.rb
 - lib/dispatch-rider/logging/lifecycle_logger.rb
 - lib/dispatch-rider/logging/text_formatter.rb
+- lib/dispatch-rider/logging/translator.rb
+- lib/dispatch-rider/logging/translator/base_translator.rb
+- lib/dispatch-rider/logging/translator/complete_translator.rb
+- lib/dispatch-rider/logging/translator/error_handler_fail_translator.rb
+- lib/dispatch-rider/logging/translator/fail_translator.rb
+- lib/dispatch-rider/logging/translator/start_translator.rb
+- lib/dispatch-rider/logging/translator/stop_translator.rb
+- lib/dispatch-rider/logging/translator/success_translator.rb
 - lib/dispatch-rider/message.rb
 - lib/dispatch-rider/notification_services.rb
 - lib/dispatch-rider/notification_services/aws_sns.rb
@@ -163,6 +170,7 @@ files:
 - lib/generators/dispatch_rider/job/templates/handler/handler_spec.rb.erb
 - lib/generators/dispatch_rider/job/templates/publisher/publisher.rb.erb
 - lib/generators/dispatch_rider/job/templates/publisher/publisher_spec.rb.erb
+- spec/factories/messages.rb
 - spec/fixtures/handlers/another_test_handler.rb
 - spec/fixtures/handlers/test_handler.rb
 - spec/integration/logging_spec.rb
@@ -178,6 +186,7 @@ files:
 - spec/lib/dispatch-rider/logging/json_formatter_spec.rb
 - spec/lib/dispatch-rider/logging/lifecycle_logger_spec.rb
 - spec/lib/dispatch-rider/logging/text_formatter_spec.rb
+- spec/lib/dispatch-rider/logging/translator_spec.rb
 - spec/lib/dispatch-rider/message_spec.rb
 - spec/lib/dispatch-rider/notification_services/aws_sns_spec.rb
 - spec/lib/dispatch-rider/notification_services/base_spec.rb
@@ -240,6 +249,7 @@ specification_version: 4
 summary: Messaging system that is customizable based on which queueing system we are
   using.
 test_files:
+- spec/factories/messages.rb
 - spec/fixtures/handlers/another_test_handler.rb
 - spec/fixtures/handlers/test_handler.rb
 - spec/integration/logging_spec.rb
@@ -255,6 +265,7 @@ test_files:
 - spec/lib/dispatch-rider/logging/json_formatter_spec.rb
 - spec/lib/dispatch-rider/logging/lifecycle_logger_spec.rb
 - spec/lib/dispatch-rider/logging/text_formatter_spec.rb
+- spec/lib/dispatch-rider/logging/translator_spec.rb
 - spec/lib/dispatch-rider/message_spec.rb
 - spec/lib/dispatch-rider/notification_services/aws_sns_spec.rb
 - spec/lib/dispatch-rider/notification_services/base_spec.rb

data/lib/dispatch-rider/logging/base_formatter.rb

@@ -1,30 +0,0 @@
-module DispatchRider
-  module Logging
-    class BaseFormatter
-      def format_error_handler_fail(*)
-        raise NotImplementedError
-      end
-
-      def format_got_stop(*)
-        raise NotImplementedError
-      end
-
-      def format_handling(*)
-        raise NotImplementedError
-      end
-
-      private
-
-      def message_info_arguments(message)
-        message.body.dup.tap do |m|
-          m.delete('guid')
-          m.delete('object_id')
-        end
-      end
-
-      def format_duration(duration)
-        format '%.2f', duration
-      end
-    end
-  end
-end