expeditor 0.5.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5ee9877b9a720af63ec3a4163d680e43d734c4b7
-  data.tar.gz: 8707da47bb651151d0c9a2306dcbe237e165cfe5
+SHA256:
+  metadata.gz: a260bbe17a9db35fafb969bd979d87cfc74c7f9b23932567b7f6dd3f378c2a98
+  data.tar.gz: 044615f3a206c7948f60e6fbaeb9f9c055ac1320e016c165123ddf58ec4ff5fc
 SHA512:
-  metadata.gz: 7889e85b9081df0c1aecc1039e0b2193224effe67d5169c6c100027714909b4616cb5c913a02d808bdf0e21669cdfd36ea22829dea1eb4bdc09df8dc0a8e95b5
-  data.tar.gz: c36f0c9b174b2043de7da8628afa6379f655d38a57538d99669e5124e24eff5e067ed96ad209e0a25ddc70cdcdaf7171c3de21c9ffbcb99e85ef78c6015b3864
+  metadata.gz: 76dbc470fe709056315dda8d7cdbf63bd8b0ada4a62f735cbb9a7ff87c70b80aff42cd6775036a0b82a23652730d06bb878335444ce69db31f6544dd5516f109
+  data.tar.gz: 39e8389e033b6a2e7d2c4af73105380e878d6426002d8644253e63a3c2315de1d9730b69f9d17c306aa2d31b883e585b0968ba151b52e46ec3c12421ddffbc29

data/.gitignore

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

data/.travis.yml

@@ -1,10 +1,12 @@
 language: ruby
-sudo: false
 cache: bundler
 rvm:
-  - 2.1
-  - 2.2
-  - 2.3.0
+  - 2.1.10
+  - 2.2.10
+  - 2.3.8
+  - 2.4.6
+  - 2.5.5
+  - 2.6.2
   - ruby-head
 matrix:
   allow_failures:

data/CHANGELOG.md

@@ -1,7 +1,20 @@
-<!-- ## Master (unreleased) -->
+## 0.7.1
+- Fix Ruby 2 style keyword arguments to support Ruby 3 [#45](https://github.com/cookpad/expeditor/pull/27)
 
-## 0.5.0
+## 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
+- Return proper status of service [#26](https://github.com/cookpad/expeditor/pull/26)
+  - Use `Expeditor::Service#status` instead of `#current_status`
 
+## 0.5.0
 - Add a `current_thread` option of `Expeditor::Command#start` method to execute a task on current thread [#13](https://github.com/cookpad/expeditor/pull/13)
 - Drop support for MRI 2.0.x [#15](https://github.com/cookpad/expeditor/pull/15)
 - Deprecate Expeditor::Command#with_fallback. Use `set_fallback` instead [#14](https://github.com/cookpad/expeditor/pull/14)

data/README.md

@@ -126,20 +126,25 @@ command = Expeditor::Command.new(service: service) do
   ...
 end
 
-service.current_status
+service.status
 # => #<Expeditor::Status:0x007fdeeeb18468 @break=0, @dependency=0, @failure=0, @rejection=0, @success=0, @timeout=0>
 
 service.reset_status!  # reset status in the service
 ```
 
 ### circuit breaker
+The circuit breaker needs a service metrics (success, failure, timeout, ...) to decide open the circuit or not.
+Expeditor's circuit breaker has a few configuration for how it collects service metrics and how it opens the circuit.
+
+For service metrics, Expeditor collects them with the given time window.
+The metrics is gradually collected by breaking given time window into some peice of short time windows and resetting previous metrics when passing each short time window.
 
 ```ruby
 service = Expeditor::Service.new(
-  period: 10,          # retention period of the service metrics (success, failure, timeout, ...)
-  sleep: 1,            # if once the circuit is opened, the circuit is still open until sleep time is passed even though failure rate is less than threshold
-  threshold: 0.5,      # if the failure rate is more than or equal to threshold, the circuit is opened
-  non_break_count: 100 # if the total count of metrics is not more than non_break_count, the circuit is not opened even though failure rate is more than threshold
+  threshold: 0.5,      # If the failure rate is more than or equal to threshold, the circuit will be opened.
+  sleep: 1,            # If once the circuit is opened, the circuit is still open until sleep time seconds is passed even though failure rate is less than threshold.
+  non_break_count: 20, # If the total count of metrics is not more than non_break_count, the circuit is not opened even though failure rate is more than threshold.
+  period: 10,          # Time window of collecting metrics (in seconds).
 )
 
 command = Expeditor::Command.new(service: service) do
@@ -147,6 +152,17 @@ command = Expeditor::Command.new(service: service) do
 end
 ```
 
+`non_break_count` is used to ignore requests to the service which is not frequentlly requested. Configure this value considering your estimated "requests per period to the service".
+For example, when `period = 10` and `non_break_count = 20` and the requests do not occur more than 20 per 10 seconds, the circuit never opens because Expeditor ignores that "small number of requests".
+If you don't ignore the failures in that case, set `non_break_count` to smaller value than `20`.
+
+The default values are:
+
+- threshold: 0.5
+- sleep: 1
+- non_break_count: 20
+- period: 10
+
 ### synchronous execution
 
 Use `current_thread` option of `#start`, command executes synchronous on current thread.

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/examples/circuit_breaker.rb

@@ -0,0 +1,27 @@
+require 'expeditor'
+
+service = Expeditor::Service.new
+
+i = 1
+loop do
+  puts '=' * 100
+  p i
+
+  command = Expeditor::Command.new(service: service, timeout: 1) {
+    sleep 0.001 # simulate remote resource access
+    if File.exist?('foo')
+      'result'
+    else
+      raise 'Demo error'
+    end
+  }.set_fallback { |e|
+    p e
+    'default value'
+  }.start
+
+  p command.get
+  p service.status
+  puts
+
+  i += 1
+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/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,32 +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)
-              @ivar.send(:complete, success, value, reason)
-            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) # is 0.5 ok?
-      @non_break_count = opts.fetch(:non_break_count, 100) # is 100 ok?
+      @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
@@ -70,20 +96,28 @@ module Expeditor
       @executor.shutdown
     end
 
+    def status
+      @rolling_number.total
+    end
+
+    # @deprecated Use `#status` instead.
     def current_status
-      @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
@@ -92,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.5.0"
+  VERSION = "0.7.1"
 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/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.5.0
+  version: 0.7.1
 platform: ruby
 authors:
 - shohei-yasutake
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2016-08-29 00:00:00.000000000 Z
+date: 2022-04-27 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
@@ -111,23 +125,26 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/circuit_breaker.rb
 - 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
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -142,9 +159,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.3.8
+signing_key:
 specification_version: 4
 summary: Expeditor provides asynchronous execution and fault tolerance for microservices
 test_files: []

data/lib/expeditor/bucket.rb

@@ -1,79 +0,0 @@
-require 'expeditor/status'
-
-module Expeditor
-  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 |acc, s|
-          acc[0] += s.success
-          acc[1] += s.failure
-          acc[2] += s.rejection
-          acc[3] += s.timeout
-          acc[4] += s.break
-          acc[5] += s.dependency
-          acc
-        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