services 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b3bc560efbbf48e28224e43a9b0c38a94c0e3e3
-  data.tar.gz: 139c86d2e85f88781eb1999fb80123a18c66e009
+  metadata.gz: b6a69a25c27cff265025953ddd3dfaa6f04a4f7e
+  data.tar.gz: fd175797287181892a619c61dd195d1062919ad4
 SHA512:
-  metadata.gz: 48140e2d271a70fba7de535c1ce8249937e25013c02640265f877e3f6d9f2e8c81ed4288abfd30ba3eeecdce0a76b5a0a1e2e2191825f54038fc62591281650c
-  data.tar.gz: 94d5b1d545f3d3b72e1e343579f84452219f03ba6528380fbf8b9d635eaf944774ea127cd8f23dd67a116fef55a5d3972728e4afe35c847992ae59ac446e7fd6
+  metadata.gz: 1bb62070e8e679707ab12e04590a80a90e61895f02f2aca643248040f57d60257de7e29bc34dc306f89382f2fbf46c5e918a4e0055a52948f4e8a517c0bfe68c
+  data.tar.gz: 772463884aa0a6ddd64bd5ab83fa311c9881bd4e8156a5fb61253a4ed2c3d0529d5570d842ea99327a92d7adbc42e3f23239d6b05707fe200b8fdccad6a4de87

data/lib/services/modules/call_logger.rb

@@ -3,7 +3,7 @@ module Services
     module CallLogger
       def call(*args)
         log "START with args #{args}"
-        log "CALLED BY #{caller}"
+        log "CALLED BY #{caller || '(not found)'}"
         start = Time.now
         begin
           result = super
@@ -38,10 +38,16 @@ module Services
       end
 
       def caller
-        caller_location = caller_locations(2, 1).first
-        caller_path = caller_location.path
-        caller_path = caller_path.sub(%r(\A#{Regexp.escape Rails.root.to_s}/), '') if defined?(Rails)
-        [caller_path, caller_location.lineno].join(':')
+        caller_location = caller_locations(1, 10).detect do |location|
+          location.path !~ /\A#{Regexp.escape File.expand_path('../..', __FILE__)}/
+        end
+        if caller_location.nil?
+          nil
+        else
+          caller_path = caller_location.path
+          caller_path = caller_path.sub(%r(\A#{Regexp.escape Rails.root.to_s}/), '') if defined?(Rails)
+          [caller_path, caller_location.lineno].join(':')
+        end
       end
     end
   end

data/lib/services/modules/uniqueness_checker.rb

@@ -6,35 +6,66 @@ module Services
         uniqueness
       ).join(':')
 
+      ON_ERROR = %i(
+        fail
+        ignore
+        reschedule
+      )
+
+      MAX_RETRIES = 10
+      ONE_HOUR = 60 * 60
+
       def self.prepended(mod)
         mod.const_set :NotUniqueError, Class.new(mod::Error)
       end
 
-      def check_uniqueness!(*args)
-        if args.empty?
-          raise 'Could not find uniqueness args' unless defined?(@uniqueness_args)
-          args = @uniqueness_args
-        end
-        new_uniqueness_key = uniqueness_key(args)
-        if similar_service_id = Services.configuration.redis.get(new_uniqueness_key)
-          raise self.class::NotUniqueError, "Service #{self.class} with uniqueness args #{args} is not unique, a similar service is already running: #{similar_service_id}"
+      def check_uniqueness!(*args, on_error: :fail)
+        raise "on_error must be one of #{ON_ERROR.join(', ')}, but was #{on_error}" unless ON_ERROR.include?(on_error.to_sym)
+        raise 'Service args not found.' if @service_args.nil?
+        @uniqueness_args = args.empty? ? @service_args : args
+        new_uniqueness_key = uniqueness_key(@uniqueness_args)
+        raise "A uniqueness key with args #{@uniqueness_args.inspect} already exists." if @uniqueness_keys && @uniqueness_keys.include?(new_uniqueness_key)
+        if @similar_service_id = Services.configuration.redis.get(new_uniqueness_key)
+          case on_error.to_sym
+          when :ignore
+            false
+          when :fail
+            raise_non_unique_error
+          when :reschedule
+            error_count = (Services.configuration.redis.get(error_count_key) || 0).to_i
+            if error_count >= MAX_RETRIES
+              raise_non_unique_error
+            else
+              error_count += 1
+              self.class.perform_in retry_delay(error_count), @service_args
+              Services.configuration.redis.setex error_count_key, retry_delay(error_count) + ONE_HOUR, error_count
+              false
+            end
+          end
         else
           @uniqueness_keys ||= []
-          raise "A uniqueness key with args #{args.inspect} already exists." if @uniqueness_keys.include?(new_uniqueness_key)
           @uniqueness_keys << new_uniqueness_key
-          Services.configuration.redis.setex new_uniqueness_key, 60 * 60, @id
+          Services.configuration.redis.setex new_uniqueness_key, ONE_HOUR, @id
+          true
         end
       end
 
       def call(*args)
-        @uniqueness_args = args
+        @service_args = args
         super
       ensure
         Services.configuration.redis.del @uniqueness_keys unless @uniqueness_keys.nil? || @uniqueness_keys.empty?
+        Services.configuration.redis.del error_count_key
       end
 
       private
 
+      def raise_non_unique_error(retried = false)
+        message = "Service #{self.class} #{@id} with uniqueness args #{@uniqueness_args} is not unique, a similar service is already running: #{@similar_service_id}."
+        message << " The service has been retried #{MAX_RETRIES} times."
+        raise self.class::NotUniqueError, message
+      end
+
       def uniqueness_key(args)
         [
           KEY_PREFIX,
@@ -43,6 +74,20 @@ module Services
           key << Digest::MD5.hexdigest(args.to_s) unless args.empty?
         end.join(':')
       end
+
+      def error_count_key
+        [
+          KEY_PREFIX,
+          'errors',
+          self.class.to_s
+        ].tap do |key|
+          key << Digest::MD5.hexdigest(@service_args.to_s) unless @service_args.empty?
+        end.join(':')
+      end
+
+      def retry_delay(error_count)
+        (error_count ** 3) + 5
+      end
     end
   end
 end

data/lib/services/version.rb

@@ -1,3 +1,3 @@
 module Services
-  VERSION = '0.2.8'
+  VERSION = '0.2.9'
 end

data/spec/services/base_spec.rb

@@ -58,172 +58,6 @@ describe Services::Base do
     end
   end
 
-  if StandardError.new.respond_to?(:cause)
-    context 'wrapping exceptions' do
-      it 'does not wrap service errors or subclasses' do
-        expect do
-          ErrorService.call
-        end.to raise_error do |error|
-          expect(error).to be_a(ErrorService::Error)
-          expect(error.message).to eq('I am a service error.')
-          expect(error.cause).to be_nil
-        end
-
-        class ServiceWithCustomError < Services::Base
-          CustomError = Class.new(self::Error)
-          def call
-            raise CustomError.new('I am a custom error.')
-          end
-        end
-        expect do
-          ServiceWithCustomError.call
-        end.to raise_error do |error|
-          expect(error).to be_a(ServiceWithCustomError::CustomError)
-          expect(error.message).to eq('I am a custom error.')
-          expect(error.cause).to be_nil
-        end
-      end
-
-      it 'wraps all other exceptions' do
-        class ServiceWithStandardError < Services::Base
-          def call
-            raise 'I am a StandardError.'
-          end
-        end
-        expect do
-          ServiceWithStandardError.call
-        end.to raise_error do |error|
-          expect(error).to be_a(ServiceWithStandardError::Error)
-          expect(error.message).to eq('I am a StandardError.')
-          expect(error.cause).to be_a(StandardError)
-          expect(error.cause.message).to eq('I am a StandardError.')
-        end
-
-        class ServiceWithCustomStandardError < Services::Base
-          CustomStandardError = Class.new(StandardError)
-          def call
-            raise CustomStandardError, 'I am a custom StandardError.'
-          end
-        end
-        expect do
-          ServiceWithCustomStandardError.call
-        end.to raise_error do |error|
-          expect(error).to be_a(ServiceWithCustomStandardError::Error)
-          expect(error.message).to eq('I am a custom StandardError.')
-          expect(error.cause).to be_a(ServiceWithCustomStandardError::CustomStandardError)
-          expect(error.cause.message).to eq('I am a custom StandardError.')
-        end
-      end
-    end
-  end
-
-  context 'checking for uniqueness' do
-    context 'when the service checks for uniqueness with the default args' do
-      it 'raises an error when the same job is executed multiple times' do
-        wait_for_job_to_run UniqueService do
-          3.times do
-            expect { UniqueService.call }.to raise_error(UniqueService::NotUniqueError)
-          end
-        end
-      end
-    end
-
-    context 'when the service checks for uniqueness with custom args' do
-      it 'raises an error when a job with the same custom args is executed multiple times' do
-        wait_for_job_to_run UniqueWithCustomArgsService, 'foo', 'bar', 'baz' do
-          3.times do
-            expect { UniqueWithCustomArgsService.call('foo', 'bar', 'pelle') }.to raise_error(UniqueWithCustomArgsService::NotUniqueError)
-          end
-          expect { UniqueWithCustomArgsService.call('foo', 'baz', 'pelle') }.to_not raise_error
-        end
-      end
-    end
-
-    context 'when the service checks for uniqueness multiple times' do
-      let(:args) { %w(foo bar baz) }
-
-      it 'raises an error when one of the checks fails' do
-        wait_for_job_to_run UniqueMultipleService, *args do
-          args.each do |arg|
-            3.times do
-              expect { UniqueMultipleService.call(arg) }.to raise_error(UniqueMultipleService::NotUniqueError)
-            end
-          end
-          expect { UniqueMultipleService.call('pelle') }.to_not raise_error
-        end
-      end
-
-      it 'does not leave any Redis keys behind' do
-        expect do
-          wait_for_job_to_run_and_finish UniqueMultipleService, *args do
-            args.each do |arg|
-              UniqueMultipleService.call(arg) rescue nil
-            end
-            UniqueMultipleService.call('pelle')
-          end
-        end.to_not change {
-          Services.configuration.redis.keys("*#{Services::Base::UniquenessChecker::KEY_PREFIX}*").count
-        }
-      end
-    end
-
-    context 'when the service was not set to check for uniqueness' do
-      it 'does not raise an error when the same job is executed twice' do
-        wait_for_job_to_run NonUniqueService do
-          expect { NonUniqueService.call }.to_not raise_error
-        end
-      end
-    end
-  end
-
-  context 'logging' do
-    it 'logs start with args and end with duration' do
-      service = EmptyService.new
-      logs = []
-      allow(service).to receive(:log) do |message, *|
-        logs << message
-      end
-      service.call 'foo', 'bar'
-      expect(logs.first).to eq('START with args ["foo", "bar"]')
-      expect(logs.last).to eq('END after 0.0 seconds')
-    end
-
-    it 'logs the caller' do
-      service_calling_service, called_service = ServiceCallingService.new, EmptyService.new
-      logs = []
-      allow(called_service).to receive(:log) do |message, *|
-        logs << message
-      end
-
-      # When Rails is not defined, the complete caller path should be logged
-      service_calling_service.call called_service
-      expect(logs).to include(/\ACALLED BY #{Regexp.escape(PROJECT_ROOT.join(SERVICES_PATH).to_s)}:\d+/)
-
-      # When Rails is defined, only the caller path relative to Rails.root is logged
-      class Rails
-        def self.root; PROJECT_ROOT; end
-      end
-      logs = []
-      service_calling_service.call called_service
-      expect(logs).to include(/\ACALLED BY #{Regexp.escape(SERVICES_PATH)}:\d+/)
-      Object.send :remove_const, :Rails
-    end
-
-    if RUBY_VERSION > '2.1'
-      it 'logs exceptions and exception causes' do
-        service = NestedExceptionService.new
-        logs = []
-        allow(service).to receive(:log) do |message, *|
-          logs << message
-        end
-        expect { service.call }.to raise_error(NestedExceptionService::Error)
-        %w(NestedError1 NestedError2).each do |error|
-          expect(logs).to include(/\Acaused by: NestedExceptionService::#{error}/)
-        end
-      end
-    end
-  end
-
   context 'when executed asynchronously' do
     it 'finds its own worker' do
       3.times { OwnWorkerService.perform_async }

data/spec/services/modules/call_logger_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Services::Base::CallLogger do
+  it 'logs start with args and end with duration' do
+    service = EmptyService.new
+    logs = []
+    allow(service).to receive(:log) do |message, *|
+      logs << message
+    end
+    service.call 'foo', 'bar'
+    expect(logs.first).to eq('START with args ["foo", "bar"]')
+    expect(logs.last).to eq('END after 0.0 seconds')
+  end
+
+  it 'logs the caller' do
+    service_calling_service, called_service = ServiceCallingService.new, EmptyService.new
+    logs = []
+    allow(called_service).to receive(:log) do |message, *|
+      logs << message
+    end
+
+    # When Rails is not defined, the complete caller path should be logged
+    service_calling_service.call called_service
+    expect(logs).to include(/\ACALLED BY #{Regexp.escape PROJECT_ROOT.join(TEST_SERVICES_PATH).to_s}:\d+/)
+
+    # When Rails is defined, only the caller path relative to Rails.root is logged
+    class Rails
+      def self.root; PROJECT_ROOT; end
+    end
+    logs = []
+    service_calling_service.call called_service
+    expect(logs).to include(/\ACALLED BY #{Regexp.escape TEST_SERVICES_PATH.to_s}:\d+/)
+    Object.send :remove_const, :Rails
+
+    # Caller paths from services lib folder should be filtered
+    require 'services/call_proxy'
+    logs = []
+    Services::CallProxy.call(called_service, :call)
+    expect(logs).to include(/\ACALLED BY #{Regexp.escape __FILE__}:\d+/)
+  end
+
+  if RUBY_VERSION > '2.1'
+    it 'logs exceptions and exception causes' do
+      service = NestedExceptionService.new
+      logs = []
+      allow(service).to receive(:log) do |message, *|
+        logs << message
+      end
+      expect { service.call }.to raise_error(service.class::Error)
+      %w(NestedError1 NestedError2).each do |error|
+        expect(logs).to include(/\Acaused by: #{service.class}::#{error}/)
+      end
+    end
+  end
+end

data/spec/services/modules/exception_wrapper_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Services::Base::ExceptionWrapper do
+  if StandardError.new.respond_to?(:cause)
+    it 'does not wrap service errors or subclasses' do
+      expect do
+        ErrorService.call
+      end.to raise_error do |error|
+        expect(error).to be_a(ErrorService::Error)
+        expect(error.message).to eq('I am a service error.')
+        expect(error.cause).to be_nil
+      end
+
+      class ServiceWithCustomError < Services::Base
+        CustomError = Class.new(self::Error)
+        def call
+          raise CustomError.new('I am a custom error.')
+        end
+      end
+      expect do
+        ServiceWithCustomError.call
+      end.to raise_error do |error|
+        expect(error).to be_a(ServiceWithCustomError::CustomError)
+        expect(error.message).to eq('I am a custom error.')
+        expect(error.cause).to be_nil
+      end
+    end
+
+    it 'wraps all other exceptions' do
+      class ServiceWithStandardError < Services::Base
+        def call
+          raise 'I am a StandardError.'
+        end
+      end
+      expect do
+        ServiceWithStandardError.call
+      end.to raise_error do |error|
+        expect(error).to be_a(ServiceWithStandardError::Error)
+        expect(error.message).to eq('I am a StandardError.')
+        expect(error.cause).to be_a(StandardError)
+        expect(error.cause.message).to eq('I am a StandardError.')
+      end
+
+      class ServiceWithCustomStandardError < Services::Base
+        CustomStandardError = Class.new(StandardError)
+        def call
+          raise CustomStandardError, 'I am a custom StandardError.'
+        end
+      end
+      expect do
+        ServiceWithCustomStandardError.call
+      end.to raise_error do |error|
+        expect(error).to be_a(ServiceWithCustomStandardError::Error)
+        expect(error.message).to eq('I am a custom StandardError.')
+        expect(error.cause).to be_a(ServiceWithCustomStandardError::CustomStandardError)
+        expect(error.cause.message).to eq('I am a custom StandardError.')
+      end
+    end
+  end
+end

data/spec/services/modules/uniqueness_checker_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+shared_examples 'checking the uniqueness properly' do
+  it 'notices when the same job is executed multiple times' do
+    # Check that error is raised when on_error is "fail"
+    wait_for_job_to_run_and_finish service, *args, 'fail', true do
+      if defined?(fail_args)
+        3.times do
+          fail_args.each do |fail_arg_group|
+            expect { service.call(*fail_arg_group, 'fail', false) }.to raise_error(service::NotUniqueError)
+          end
+        end
+      end
+      if defined?(pass_args)
+        3.times do
+          pass_args.each do |pass_arg_group|
+            expect { service.call(*pass_arg_group, 'fail', false) }.to_not raise_error
+          end
+        end
+      end
+
+      # Check that no error is raised when on_error is "ignore"
+      if defined?(fail_args)
+        3.times do
+          fail_args.each do |fail_arg_group|
+            expect { service.call(*fail_arg_group, 'ignore', false) }.to_not raise_error
+          end
+        end
+      end
+      if defined?(pass_args)
+        3.times do
+          pass_args.each do |pass_arg_group|
+            expect { service.call(*pass_arg_group, 'ignore', false) }.to_not raise_error
+          end
+        end
+      end
+
+      # Check that service is rescheduled when on_error is "reschedule"
+      if defined?(fail_args)
+        3.times do
+          fail_args.each do |fail_arg_group|
+            expect(service).to receive(:perform_in).with(an_instance_of(Fixnum), fail_arg_group + (['reschedule', false]))
+            service.call(*fail_arg_group, 'reschedule', false)
+          end
+        end
+      end
+      if defined?(pass_args)
+        3.times do
+          pass_args.each do |pass_arg_group|
+            expect { service.call(*pass_arg_group, 'reschedule', false) }.to_not raise_error
+          end
+        end
+      end
+    end
+  end
+end
+
+describe Services::Base::UniquenessChecker do
+  context 'when the service checks for uniqueness with the default args' do
+    it_behaves_like 'checking the uniqueness properly' do
+      let(:service)          { UniqueService }
+      let(:args)             { [] }
+      let(:fail_args)        { [] }
+      let(:keys_after_start) { 1 }
+    end
+  end
+
+  context 'when the service checks for uniqueness with custom args' do
+    it_behaves_like 'checking the uniqueness properly' do
+      let(:service)          { UniqueWithCustomArgsService }
+      let(:args)             { %w(foo bar baz) }
+      let(:fail_args)        { [%w(foo bar pelle)] }
+      let(:pass_args)        { [%w(foo baz pelle)] }
+      let(:keys_after_start) { 1 }
+    end
+  end
+
+  context 'when the service checks for uniqueness multiple times' do
+    it_behaves_like 'checking the uniqueness properly' do
+      let(:service)          { UniqueMultipleService }
+      let(:args)             { %w(foo bar baz) }
+      let(:fail_args)        { args.map { |arg| [arg] } }
+      let(:pass_args)        { [%w(pelle)] }
+      let(:keys_after_start) { 3 }
+    end
+  end
+
+  context 'when the service does not check for uniqueness' do
+    it_behaves_like 'checking the uniqueness properly' do
+      let(:service)          { NonUniqueService }
+      let(:args)             { [] }
+      let(:pass_args)        { [] }
+      let(:keys_after_start) { 0 }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,15 +4,16 @@ require 'redis'
 require 'sidekiq'
 
 require_relative '../lib/services'
-require_relative 'support/helpers'
 
-SERVICES_PATH = File.join('support', 'test_services.rb')
-require_relative SERVICES_PATH
+PROJECT_ROOT       = Pathname.new(File.expand_path('../..', __FILE__))
+TEST_SERVICES_PATH = Pathname.new(File.join('spec', 'support', 'test_services.rb'))
+support_dir        = Pathname.new(File.expand_path('../support', __FILE__))
+log_dir            = support_dir.join('log')
 
-PROJECT_ROOT = Pathname.new(File.expand_path('..', __FILE__))
+CALL_PROXY_SOURCE      = support_dir.join('call_proxy.rb')
+CALL_PROXY_DESTINATION = PROJECT_ROOT.join('lib', 'services', 'call_proxy.rb')
 
-support_dir = Pathname.new(File.expand_path('../support', __FILE__))
-log_dir     = support_dir.join('log')
+Dir[support_dir.join('**', '*.rb')].each { |f| require f }
 
 redis_port    = 6379
 redis_pidfile = support_dir.join('redis.pid')
@@ -65,9 +66,15 @@ RSpec.configure do |config|
       pidfile:     sidekiq_pidfile
     }
     system "bundle exec sidekiq #{options_hash_to_string(sidekiq_options)}"
+
+    # Copy call proxy
+    FileUtils.cp CALL_PROXY_SOURCE, CALL_PROXY_DESTINATION
   end
 
   config.after :suite do
+    # Delete call proxy
+    FileUtils.rm CALL_PROXY_DESTINATION
+
     # Stop Sidekiq
     system "bundle exec sidekiqctl stop #{sidekiq_pidfile} #{sidekiq_timeout}"
     while File.exist?(sidekiq_pidfile)

data/spec/support/call_proxy.rb

@@ -0,0 +1,11 @@
+# This is just a helper file to ensure that
+# the services lib folder appears in the caller
+# locations.
+
+module Services
+  class CallProxy
+    def self.call(object, method)
+      object.public_send method
+    end
+  end
+end

data/spec/support/test_services.rb

@@ -65,31 +65,31 @@ class ServiceCallingService < Services::Base
 end
 
 class UniqueService < Services::Base
-  def call
-    check_uniqueness!
-    sleep 0.5
+  def call(on_error, sleep)
+    check_uniqueness! on_error: on_error
+    sleep 0.5 if sleep
   end
 end
 
 class UniqueWithCustomArgsService < Services::Base
-  def call(uniqueness_arg1, uniqueness_arg2, ignore_arg)
-    check_uniqueness! uniqueness_arg1, uniqueness_arg2
-    sleep 0.5
+  def call(uniqueness_arg1, uniqueness_arg2, ignore_arg, on_error, sleep)
+    check_uniqueness! uniqueness_arg1, uniqueness_arg2, on_error: on_error
+    sleep 0.5 if sleep
   end
 end
 
 class UniqueMultipleService < Services::Base
-  def call(*args)
+  def call(*args, on_error, sleep)
     args.each do |arg|
-      check_uniqueness! arg
+      check_uniqueness! arg, on_error: on_error
     end
-    sleep 0.5
+    sleep 0.5 if sleep
   end
 end
 
 class NonUniqueService < Services::Base
-  def call
-    sleep 0.5
+  def call(on_error, sleep)
+    sleep 0.5 if sleep
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: services
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - Manuel Meurer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-24 00:00:00.000000000 Z
+date: 2014-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -146,7 +146,11 @@ files:
 - lib/services/version.rb
 - services.gemspec
 - spec/services/base_spec.rb
+- spec/services/modules/call_logger_spec.rb
+- spec/services/modules/exception_wrapper_spec.rb
+- spec/services/modules/uniqueness_checker_spec.rb
 - spec/spec_helper.rb
+- spec/support/call_proxy.rb
 - spec/support/helpers.rb
 - spec/support/log/.gitkeep
 - spec/support/redis-cli
@@ -178,7 +182,11 @@ specification_version: 4
 summary: ''
 test_files:
 - spec/services/base_spec.rb
+- spec/services/modules/call_logger_spec.rb
+- spec/services/modules/exception_wrapper_spec.rb
+- spec/services/modules/uniqueness_checker_spec.rb
 - spec/spec_helper.rb
+- spec/support/call_proxy.rb
 - spec/support/helpers.rb
 - spec/support/log/.gitkeep
 - spec/support/redis-cli