expeditor 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06fd643997ffcbbcf94b5243a56f00a31e4788a3
-  data.tar.gz: 6aa12d927eab977c0d0b6c822b78b37877555637
+  metadata.gz: '0295f51ed41290a443f84e29704254cb92773e54'
+  data.tar.gz: d4525b17a023e7aed723ed8b5d40cc7842d14d6a
 SHA512:
-  metadata.gz: f81815f7920543475b352185f62dca303173988600a16db97b329662f72d6405e14b7efd834b3ff2eb7d393e9eccf3daa4a8eb4072d36997c33cdca2e1f16ea0
-  data.tar.gz: 1623ce5ccf9f6537e6ce87f0b056742dec4d71157c9108aedefbf4fd2924fa41211c50c76d13f8e9bedaa15d25a1192af2fe5d1f2994d2ad4f33cad7719788f6
+  metadata.gz: 5c07b956a48818d56ae0edfc9f282c21ffa7e90ba3432b91d3abba8a095456281cdc6ce22a8a887e72c096b94525a12fa9ddf72929761644df05492f70d02ea7
+  data.tar.gz: 047f91f6875c87e815796801f5a67e49b4d1bcb1821a7c36c8e4835ae6c1cd0a0cfc7992d69a079b1afeb6ec9ad8e6ddf4dcbbfb1b06bbfe97476bc42dcafcf3

data/.gitignore

@@ -8,3 +8,4 @@
 /spec/reports/
 /tmp/
 /vendor/
+.ruby-version

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.7.0
+- Add `gem 'concurrent-ruby-ext'` to your Gemfile if you want to use that gem.
+    - We should not depend on this in a gemspec [#27](https://github.com/cookpad/expeditor/pull/27)
+- Fix possible race conditions.
+- Fix bug on cutting passing size [#30](https://github.com/cookpad/expeditor/pull/30)
+- Implement sleep feature on circuit breaker [#36](https://github.com/cookpad/expeditor/pull/36)
+
 ## 0.6.0
 - Improve default configuration of circuit breaker [#25](https://github.com/cookpad/expeditor/pull/25)
   - Default `non_break_count` is reduced from 100 to 20

data/Rakefile

@@ -2,4 +2,9 @@ require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
-task default: :spec
+task default: [:spec, :performance_test]
+
+desc 'Check performance'
+task :performance_test do
+  ruby 'scripts/command_performance.rb'
+end

data/expeditor.gemspec

@@ -21,11 +21,12 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.1.0'
 
-  spec.add_runtime_dependency "concurrent-ruby", "~> 1.0.0"
-  spec.add_runtime_dependency "concurrent-ruby-ext", "~> 1.0.0"
+  spec.add_runtime_dependency "concurrent-ruby", ">= 1.0.0"
   spec.add_runtime_dependency "retryable", "> 1.0"
 
+  spec.add_development_dependency "benchmark-ips"
   spec.add_development_dependency "bundler"
+  spec.add_development_dependency "concurrent-ruby-ext", ">= 1.0.0"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", ">= 3.0.0"
 end

data/lib/expeditor.rb

@@ -1,4 +1,4 @@
-require 'expeditor/bucket'
+require 'expeditor/rolling_number'
 require 'expeditor/command'
 require 'expeditor/errors'
 require 'expeditor/rich_future'

data/lib/expeditor/command.rb

@@ -109,6 +109,9 @@ module Expeditor
       end
     end
 
+    # XXX: Raise ArgumentError when given `opts` has :dependencies
+    # because this forcefully change given :dependencies.
+    #
     # `chain` returns new command that has self as dependencies
     def chain(opts = {}, &block)
       opts[:dependencies] = [self]
@@ -125,59 +128,37 @@ module Expeditor
 
     private
 
-    def reset_fallback(&block)
-      @fallback_block = block
-    end
-
-    def breakable_block(args, &block)
-      if @service.open?
-        raise CircuitBreakError
-      else
-        block.call(*args)
-      end
-    end
-
-    def retryable_block(args, &block)
-      if @retryable_options.fulfilled?
-        Retryable.retryable(@retryable_options.value) do |retries, exception|
-          metrics(exception) if retries > 0
-          breakable_block(args, &block)
-        end
-      else
-        breakable_block(args, &block)
-      end
-    end
-
-    def timeout_block(args, &block)
-      if @timeout
-        Timeout::timeout(@timeout) do
-          retryable_block(args, &block)
+    # set future
+    # set fallback future as an observer
+    # start dependencies
+    def prepare(executor = @service.executor)
+      @normal_future = initial_normal(executor, &@normal_block)
+      @normal_future.add_observer do |_, value, reason|
+        if reason # failure
+          if @fallback_block
+            future = RichFuture.new(executor: executor) do
+              success, value, reason = Concurrent::SafeTaskExecutor.new(@fallback_block, rescue_exception: true).execute(reason)
+              if success
+                @ivar.set(value)
+              else
+                @ivar.fail(reason)
+              end
+            end
+            future.safe_execute
+          else
+            @ivar.fail(reason)
+          end
+        else # success
+          @ivar.set(value)
         end
-      else
-        retryable_block(args, &block)
       end
-    end
 
-    def metrics(reason)
-      case reason
-      when nil
-        @service.success
-      when Timeout::Error
-        @service.timeout
-      when RejectedExecutionError
-        @service.rejection
-      when CircuitBreakError
-        @service.break
-      when DependencyError
-        @service.dependency
-      else
-        @service.failure
-      end
+      @dependencies.each(&:start)
     end
 
-    # timeout do
-    #   retryable do
-    #     circuit break do
+    # timeout_block do
+    #   retryable_block do
+    #     breakable_block do
     #       block.call
     #     end
     #   end
@@ -224,36 +205,56 @@ module Expeditor
       end
     end
 
-    def on(&callback)
-      @ivar.add_observer(&callback)
+    def timeout_block(args, &block)
+      if @timeout
+        Timeout::timeout(@timeout) do
+          retryable_block(args, &block)
+        end
+      else
+        retryable_block(args, &block)
+      end
     end
 
-    # set future
-    # set fallback future as an observer
-    # start dependencies
-    def prepare(executor = @service.executor)
-      @normal_future = initial_normal(executor, &@normal_block)
-      @normal_future.add_observer do |_, value, reason|
-        if reason # failure
-          if @fallback_block
-            future = RichFuture.new(executor: executor) do
-              success, value, reason = Concurrent::SafeTaskExecutor.new(@fallback_block, rescue_exception: true).execute(reason)
-              if success
-                @ivar.set(value)
-              else
-                @ivar.fail(reason)
-              end
-            end
-            future.safe_execute
-          else
-            @ivar.fail(reason)
-          end
-        else # success
-          @ivar.set(value)
+    def retryable_block(args, &block)
+      if @retryable_options.fulfilled?
+        Retryable.retryable(@retryable_options.value) do |retries, exception|
+          metrics(exception) if retries > 0
+          breakable_block(args, &block)
         end
+      else
+        breakable_block(args, &block)
       end
+    end
 
-      @dependencies.each(&:start)
+    def breakable_block(args, &block)
+      @service.run_if_allowed do
+        block.call(*args)
+      end
+    end
+
+    def metrics(reason)
+      case reason
+      when nil
+        @service.success
+      when Timeout::Error
+        @service.timeout
+      when RejectedExecutionError
+        @service.rejection
+      when CircuitBreakError
+        @service.break
+      when DependencyError
+        @service.dependency
+      else
+        @service.failure
+      end
+    end
+
+    def reset_fallback(&block)
+      @fallback_block = block
+    end
+
+    def on(&callback)
+      @ivar.add_observer(&callback)
     end
 
     class ConstCommand < Command

data/lib/expeditor/ring_buffer.rb

@@ -0,0 +1,76 @@
+module Expeditor
+  # Circular buffer with user-defined initialization and optimized `move`
+  # implementation. The next element will be always initialized with
+  # user-defined initialization proc.
+  #
+  # Thread unsafe.
+  class RingBuffer
+    # @params [Integer] size
+    def initialize(size, &initialize_proc)
+      raise ArgumentError.new('initialize_proc is not given') unless initialize_proc
+      @size = size
+      @initialize_proc = initialize_proc
+      @elements = Array.new(@size, &initialize_proc)
+      @current_index = 0
+    end
+
+    # @return [Object] user created object with given initialization proc.
+    def current
+      @elements[@current_index]
+    end
+
+    # @params [Integer] times How many elements will we pass.
+    # @return [Object] current element after moving.
+    def move(times)
+      cut_moving_time_if_possible(times).times do
+        next_element
+      end
+    end
+
+    # @return [Array<Object>] Array of elements.
+    def all
+      @elements
+    end
+
+    private
+
+    # This logic is used for cutting moving times. When moving times is greater
+    # than statuses size, we can cut moving times to less than statuses size
+    # because the statuses are circulated.
+    #
+    # `*` is current index.
+    # When the statuses size is 3:
+    #
+    #   [*, , ]
+    #
+    # Then when the moving times = 3, current index will be 0 (0-origin):
+    #
+    #   [*, , ] -3> [ ,*, ] -2> [ , ,*] -1> [*, , ]
+    #
+    # Then moving times = 6, current index will be 0 again:
+    #
+    #   [*, , ] -6> [ ,*, ] -5> [ , ,*] -4> [*, , ] -3> [ ,*, ] -2> [ , ,*] -1> [*, , ]
+    #
+    # In that case we can cut the moving times from 6 to 3.
+    # That is "cut moving times" here.
+    #
+    # TODO: We can write more optimized code which resets all elements with
+    # Array.new if given moving times is greater than `@size`.
+    def cut_moving_time_if_possible(times)
+      if times >= @size * 2
+        (times % @size) + @size
+      else
+        times
+      end
+    end
+
+    def next_element
+      if @current_index == @size - 1
+        @current_index = 0
+      else
+        @current_index += 1
+      end
+      @elements[@current_index] = @initialize_proc.call
+    end
+  end
+end

data/lib/expeditor/rolling_number.rb

@@ -0,0 +1,58 @@
+require 'expeditor/status'
+require 'expeditor/ring_buffer'
+
+module Expeditor
+  # A RollingNumber holds some Status objects and it rolls statuses each
+  # `per_time` (default is 1 second). This is done so that the statistics are
+  # recorded gradually with short time interval rahter than reset all the
+  # record every wide time range (default is 10 seconds).
+  class RollingNumber
+    def initialize(size:, per_time:)
+      @mutex = Mutex.new
+      @ring = RingBuffer.new(size) do
+        Expeditor::Status.new
+      end
+      @per_time = per_time
+      @current_start = Time.now
+    end
+
+    # @params [Symbol] type
+    def increment(type)
+      @mutex.synchronize do
+        update
+        @ring.current.increment(type)
+      end
+    end
+
+    # @return [Expeditor::Status] Newly created status
+    def total
+      @mutex.synchronize do
+        update
+        @ring.all.inject(Expeditor::Status.new) {|i, s| i.merge!(s) }
+      end
+    end
+
+    # @deprecated Don't use, use `#total` instead.
+    def current
+      warn 'Expeditor::RollingNumber#current is deprecated. Please use #total instead to fetch correct status object.'
+      @mutex.synchronize do
+        update
+        @ring.current
+      end
+    end
+
+    private
+
+    def update
+      passing = last_passing
+      if passing > 0
+        @current_start = @current_start + @per_time * passing
+        @ring.move(passing)
+      end
+    end
+
+    def last_passing
+      (Time.now - @current_start).div(@per_time)
+    end
+  end
+end

data/lib/expeditor/service.rb

@@ -6,62 +6,88 @@ module Expeditor
     attr_accessor :fallback_enabled
 
     def initialize(opts = {})
+      @mutex = Mutex.new
       @executor = opts.fetch(:executor) { Concurrent::ThreadPoolExecutor.new }
       @threshold = opts.fetch(:threshold, 0.5)
       @non_break_count = opts.fetch(:non_break_count, 20)
       @sleep = opts.fetch(:sleep, 1)
-      @bucket_opts = {
-        size: 10,
-        per: opts.fetch(:period, 10).to_f / 10
+      granularity = 10
+      @rolling_number_opts = {
+        size: granularity,
+        per_time: opts.fetch(:period, 10).to_f / granularity
       }
       reset_status!
       @fallback_enabled = true
     end
 
     def success
-      @bucket.increment :success
+      @rolling_number.increment :success
     end
 
     def failure
-      @bucket.increment :failure
+      @rolling_number.increment :failure
     end
 
     def rejection
-      @bucket.increment :rejection
+      @rolling_number.increment :rejection
     end
 
     def timeout
-      @bucket.increment :timeout
+      @rolling_number.increment :timeout
     end
 
     def break
-      @bucket.increment :break
+      @rolling_number.increment :break
     end
 
     def dependency
-      @bucket.increment :dependency
+      @rolling_number.increment :dependency
     end
 
     def fallback_enabled?
       !!fallback_enabled
     end
 
-    # break circuit?
-    def open?
+    def breaking?
+      @breaking
+    end
+
+    # Run given block when the request is allowed, otherwise raise
+    # Expeditor::CircuitBreakError. When breaking and sleep time was passed,
+    # the circuit breaker tries to close the circuit. So subsequent single
+    # command execution is allowed (will not be breaked) to check the service
+    # is healthy or not. The circuit breaker only allows one request so other
+    # subsequent requests will be aborted with CircuitBreakError. When the test
+    # request succeeds, the circuit breaker resets the service status and
+    # closes the circuit.
+    def run_if_allowed
       if @breaking
-        if Time.now - @break_start > @sleep
-          @breaking = false
-          @break_start = nil
+        now = Time.now
+
+        # Only one thread can be allowed to execute single request when half-opened.
+        allow_single_request = false
+        @mutex.synchronize do
+          allow_single_request = now - @break_start > @sleep
+          @break_start = now if allow_single_request
+        end
+
+        if allow_single_request
+          result = yield # This can be raise exception.
+          # The execution succeed, then
+          reset_status!
+          result
         else
-          return true
+          raise CircuitBreakError
+        end
+      else
+        open = calc_open
+        if open
+          change_state(true, Time.now)
+          raise CircuitBreakError
+        else
+          yield
         end
       end
-      open = calc_open
-      if open
-        @breaking = true
-        @break_start = Time.now
-      end
-      open
     end
 
     # shutdown thread pool
@@ -71,25 +97,27 @@ module Expeditor
     end
 
     def status
-      @bucket.total
+      @rolling_number.total
     end
 
-    # @deprecated
+    # @deprecated Use `#status` instead.
     def current_status
-      warn 'Expeditor::Service#current_status is deprecated. Please use #status instead'
-      @bucket.current
+      warn 'Expeditor::Service#current_status is deprecated. Please use #status instead.'
+      @rolling_number.current
     end
 
     def reset_status!
-      @bucket = Expeditor::Bucket.new(@bucket_opts)
-      @breaking = false
-      @break_start = nil
+      @mutex.synchronize do
+        @rolling_number = Expeditor::RollingNumber.new(@rolling_number_opts)
+        @breaking = false
+        @break_start = nil
+      end
     end
 
     private
 
     def calc_open
-      s = @bucket.total
+      s = @rolling_number.total
       total_count = s.success + s.failure + s.timeout
       if total_count >= [@non_break_count, 1].max
         failure_count = s.failure + s.timeout
@@ -98,5 +126,12 @@ module Expeditor
         false
       end
     end
+
+    def change_state(breaking, break_start)
+      @mutex.synchronize do
+        @breaking = breaking
+        @break_start = break_start
+      end
+    end
   end
 end

data/lib/expeditor/services/default.rb

@@ -28,8 +28,8 @@ module Expeditor
       def dependency
       end
 
-      def open?
-        false
+      def run_if_allowed
+        yield
       end
     end
   end

data/lib/expeditor/status.rb

@@ -1,34 +1,46 @@
 module Expeditor
+  # Thread unsafe.
   class Status
-    attr_accessor :success
-    attr_accessor :failure
-    attr_accessor :rejection
-    attr_accessor :timeout
-    attr_accessor :break
-    attr_accessor :dependency
+    attr_reader :success
+    attr_reader :failure
+    attr_reader :rejection
+    attr_reader :timeout
+    attr_reader :break
+    attr_reader :dependency
 
     def initialize
       set(0, 0, 0, 0, 0, 0)
     end
 
-    def increment(type)
+    def increment(type, i = 1)
       case type
       when :success
-        @success += 1
+        @success += i
       when :failure
-        @failure += 1
+        @failure += i
       when :rejection
-        @rejection += 1
+        @rejection += i
       when :timeout
-        @timeout += 1
+        @timeout += i
       when :break
-        @break += 1
+        @break += i
       when :dependency
-        @dependency += 1
+        @dependency += i
       else
+        raise ArgumentError.new("Unknown type: #{type}")
       end
     end
 
+    def merge!(other)
+      increment(:success, other.success)
+      increment(:failure, other.failure)
+      increment(:rejection, other.rejection)
+      increment(:timeout, other.timeout)
+      increment(:break, other.break)
+      increment(:dependency, other.dependency)
+      self
+    end
+
     def reset
       set(0, 0, 0, 0, 0, 0)
     end

data/lib/expeditor/version.rb

@@ -1,3 +1,3 @@
 module Expeditor
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/scripts/command_performance.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'expeditor'
+
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.report("simple command") do |i|
+    executor = Concurrent::ThreadPoolExecutor.new(min_threads: 100, max_threads: 100, max_queue: 100)
+    service = Expeditor::Service.new(period: 10, non_break_count: 0, threshold: 0.5, sleep: 1, executor: executor)
+
+    i.times do
+      commands = 10000.times.map do
+        Expeditor::Command.new { 1 }.start
+      end
+      command = Expeditor::Command.new(service: service, dependencies: commands) do |*vs|
+        vs.inject(0, &:+)
+      end.start
+      command.get
+
+      service.reset_status!
+    end
+  end
+
+  x.compare!
+end

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: expeditor
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - shohei-yasutake
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-24 00:00:00.000000000 Z
+date: 2017-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
 - !ruby/object:Gem::Dependency
-  name: concurrent-ruby-ext
+  name: retryable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: retryable
+  name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby-ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -115,15 +129,17 @@ files:
 - examples/example.rb
 - expeditor.gemspec
 - lib/expeditor.rb
-- lib/expeditor/bucket.rb
 - lib/expeditor/command.rb
 - lib/expeditor/errors.rb
 - lib/expeditor/rich_future.rb
+- lib/expeditor/ring_buffer.rb
+- lib/expeditor/rolling_number.rb
 - lib/expeditor/service.rb
 - lib/expeditor/services.rb
 - lib/expeditor/services/default.rb
 - lib/expeditor/status.rb
 - lib/expeditor/version.rb
+- scripts/command_performance.rb
 homepage: https://github.com/cookpad/expeditor
 licenses:
 - MIT

data/lib/expeditor/bucket.rb

@@ -1,85 +0,0 @@
-require 'expeditor/status'
-
-module Expeditor
-  # Bucket is a data structure like circular buffer. It holds some status
-  # objects and it rolls statuses each `per` time (default is 1 second). Once
-  # it reaches the end of statuses array, it backs to start of statuses array
-  # and then reset the status and resumes recording. This is done so that the
-  # statistics are recorded gradually with short time interval rahter than
-  # reset all the record every wide time range (default is 10 seconds).
-  class Bucket
-    def initialize(opts = {})
-      @mutex = Mutex.new
-      @current_index = 0
-      @size = opts.fetch(:size, 10)
-      @per_time = opts.fetch(:per, 1)
-      @current_start = Time.now
-      @statuses = [].fill(0..(@size - 1)) do
-        Expeditor::Status.new
-      end
-    end
-
-    def increment(type)
-      @mutex.synchronize do
-        update
-        @statuses[@current_index].increment type
-      end
-    end
-
-    def total
-      acc = @mutex.synchronize do
-        update
-        @statuses.inject([0, 0, 0, 0, 0, 0]) do |i, s|
-          i[0] += s.success
-          i[1] += s.failure
-          i[2] += s.rejection
-          i[3] += s.timeout
-          i[4] += s.break
-          i[5] += s.dependency
-          i
-        end
-      end
-      status = Expeditor::Status.new
-      status.success = acc[0]
-      status.failure = acc[1]
-      status.rejection = acc[2]
-      status.timeout = acc[3]
-      status.break = acc[4]
-      status.dependency = acc[5]
-      status
-    end
-
-    def current
-      @mutex.synchronize do
-        update
-        @statuses[@current_index]
-      end
-    end
-
-    private
-
-    def update
-      passing = last_passing
-      if passing > 0
-        @current_start = @current_start + @per_time * passing
-        passing = passing.div @size + @size if passing > 2 * @size
-        passing.times do
-          @current_index = next_index
-          @statuses[@current_index].reset
-        end
-      end
-    end
-
-    def last_passing
-      (Time.now - @current_start).div @per_time
-    end
-
-    def next_index
-      if @current_index == @size - 1
-        0
-      else
-        @current_index + 1
-      end
-    end
-  end
-end