resilient 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d96ef8b25a0a297da28e4c1f718ab826350a23d
-  data.tar.gz: 8bdf3b03abfedbcf9cd6531a7aad4cd2b3313a18
+  metadata.gz: 5cebeacad55c7a80623379752b452f9a20dd0009
+  data.tar.gz: 9d56f7dc8b598304b8f2aea2e6c46a743f0820f2
 SHA512:
-  metadata.gz: 067674abbd47f23741bcc38ca4c99e0ddbcfb187d4e25b84e04841e0055a34ada9e368350868de7fc5363f811e8a20631fcd7d5e13c490918b86242c3f9154f5
-  data.tar.gz: 90c8672939280363a2da23664a4ebadf5e413ce40cf08b38130e00bea1923ac5971c126f2bba5b9c4417e639f16b89e9c92d1b2289e97af3662074e1719c549f
+  metadata.gz: 63d8cb0a2f6d784573a22df49b407530ebbbe8e8cc534c678ff92d89f749e62ab9c906eb17ad490aad92ede7bf5f8bbeffa0a8e265f801b29a20131804d28647
+  data.tar.gz: 02023b4a9de5bb484fb732c28e11538aa33f0a6ee01e84bff4d1f5c85ae483886e6d1171af99a86eeebbaa5256909f0cce0a4213e4f6d24144e330566b0c6374

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.gem

data/Gemfile

@@ -1,8 +1,5 @@
 source "https://rubygems.org"
-
-# Specify your gem's dependencies in resilient.gemspec
 gemspec
 
 gem "guard", "~> 2.13.0"
 gem "guard-minitest", "~> 2.4.4"
-gem "timecop", "0.8.0"

data/Guardfile

@@ -1,23 +1,5 @@
-# A sample Guardfile
-# More info at https://github.com/guard/guard#readme
-
-## Uncomment and set this to only include directories you want to watch
-# directories %w(app lib config test spec features) \
-#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
-
-## Note: if you are using the `directories` clause above and you are not
-## watching the project directory ('.'), then you will want to move
-## the Guardfile to a watched dir and symlink it back, e.g.
-#
-#  $ mkdir config
-#  $ mv Guardfile config/
-#  $ ln -s config/Guardfile .
-#
-# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
-
 guard :minitest do
   watch(%r{^test/(.*)\/?(.*)_test\.rb$}) { "test" }
   watch(%r{^lib/(.*/)?([^/]+)\.rb$}) { "test" }
   watch(%r{^test/test_helper\.rb$}) { "test" }
-  watch(%r{test/support/.*}) { "test" }
 end

data/README.md

@@ -1,8 +1,8 @@
 # Resilient
 
-Some tools for resilient in ruby. For now, just a circuit breaker (~~stolen from~~ based on [hystrix](https://github.com/netflix/hystrix)). Soon much more...
+Some tools to aid in resiliency in ruby. For now, just a circuit breaker (~~stolen from~~ based on [hystrix](https://github.com/netflix/hystrix)). Soon much more...
 
-Nothing asynchronous or thread safe yet either.
+Nothing asynchronous or thread safe yet either, but open to it and would like to see more around it in the future.
 
 ## Installation
 
@@ -25,14 +25,14 @@ Or install it yourself as:
 ```ruby
 require "resilient/circuit_breaker"
 
-# default config for circuit
-circuit_breaker = Resilient::CircuitBreaker.new
+# default properties for circuit
+circuit_breaker = Resilient::CircuitBreaker.new(key: Resilient::Key.new("example"))
 if circuit_breaker.allow_request?
   begin
     # do something expensive
-    circuit_breaker.mark_success
+    circuit_breaker.success
   rescue => boom
-    circuit_breaker.mark_failure
+    circuit_breaker.failure
     # do fallback
   end
 else
@@ -40,10 +40,10 @@ else
 end
 ```
 
-customize config of circuit:
+customize properties of circuit:
 
 ```ruby
-config = Resilient::CircuitBreaker::Config.new({
+properties = Resilient::CircuitBreaker::Properties.new({
   # at what percentage of errors should we open the circuit
   error_threshold_percentage: 50,
   # do not try request again for 5 seconds
@@ -51,23 +51,23 @@ config = Resilient::CircuitBreaker::Config.new({
   # do not open circuit until at least 5 requests have happened
   request_volume_threshold: 5,
 })
-circuit_breaker = Resilient::CircuitBreaker.new(config: config)
+circuit_breaker = Resilient::CircuitBreaker.new(properties: properties, key: Resilient::Key.new("example"))
 # etc etc etc
 ```
 
 force the circuit to be always open:
 
 ```ruby
-config = Resilient::CircuitBreaker::Config.new(force_open: true)
-circuit_breaker = Resilient::CircuitBreaker.new(config: config)
+properties = Resilient::CircuitBreaker::Properties.new(force_open: true)
+circuit_breaker = Resilient::CircuitBreaker.new(properties: properties, key: Resilient::Key.new("example"))
 # etc etc etc
 ```
 
 force the circuit to be always closed:
 
 ```ruby
-config = Resilient::CircuitBreaker::Config.new(force_closed: true)
-circuit_breaker = Resilient::CircuitBreaker.new(config: config)
+properties = Resilient::CircuitBreaker::Properties.new(force_closed: true)
+circuit_breaker = Resilient::CircuitBreaker.new(properties: properties, key: Resilient::Key.new("example"))
 # etc etc etc
 ```
 
@@ -75,10 +75,10 @@ customize rolling window to be 10 buckets of 1 second each (10 seconds in all):
 
 ```ruby
 metrics = Resilient::CircuitBreaker::Metrics.new({
-  number_of_buckets: 10,
+  window_size_in_seconds: 10,
   bucket_size_in_seconds: 1,
 })
-circuit_breaker = Resilient::CircuitBreaker.new(metrics: metrics)
+circuit_breaker = Resilient::CircuitBreaker.new(metrics: metrics, key: Resilient::Key.new("example"))
 # etc etc etc
 ```
 
@@ -105,3 +105,9 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/jnunem
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Release (for maintainers)
+
+* increment version based on semver
+* git commit version change
+* script/release (releases to rubygems and git tags)

data/examples/basic.rb

@@ -8,21 +8,21 @@ $:.unshift(lib_path)
 require "pp"
 require "resilient/circuit_breaker"
 
-config = Resilient::CircuitBreaker::Config.new({
+properties = Resilient::CircuitBreaker::Properties.new({
   sleep_window_seconds: 1,
   request_volume_threshold: 10,
   error_threshold_percentage: 25,
 })
-circuit_breaker = Resilient::CircuitBreaker.new(config: config)
+circuit_breaker = Resilient::CircuitBreaker.new(key: Resilient::Key.new("example"), properties: properties)
 
 # success
 if circuit_breaker.allow_request?
   begin
     puts "do expensive thing"
-    circuit_breaker.mark_success
+    circuit_breaker.success
   rescue => boom
     # won't get here in this example
-    circuit_breaker.mark_failure
+    circuit_breaker.failure
   end
 else
   raise "will not get here"
@@ -33,7 +33,7 @@ if circuit_breaker.allow_request?
   begin
     raise
   rescue => boom
-    circuit_breaker.mark_failure
+    circuit_breaker.failure
     puts "failed slow, do fallback"
   end
 else
@@ -42,8 +42,8 @@ end
 
 # trip circuit, imagine this being same as above but in real life...
 # also, we have to fail at least the request volume threshold number of times
-circuit_breaker.config.request_volume_threshold.times do
-  circuit_breaker.mark_failure
+circuit_breaker.properties.request_volume_threshold.times do
+  circuit_breaker.failure
 end
 
 # fail fast
@@ -72,7 +72,7 @@ else
 end
 
 puts "marking single request as success"
-circuit_breaker.mark_success
+circuit_breaker.success
 
 if circuit_breaker.allow_request?
   puts "circuit reset and back closed now, allowing requests"

data/examples/long_running.rb

@@ -8,14 +8,14 @@ $:.unshift(lib_path)
 require "pp"
 require "resilient/circuit_breaker"
 
-config = Resilient::CircuitBreaker::Config.new({
+properties = Resilient::CircuitBreaker::Properties.new({
   sleep_window_seconds: 5,
   request_volume_threshold: 20,
   error_threshold_percentage: 10,
-  number_of_buckets: 10,
+  window_size_in_seconds: 60,
   bucket_size_in_seconds: 1,
 })
-circuit_breaker = Resilient::CircuitBreaker.new(config: config)
+circuit_breaker = Resilient::CircuitBreaker.new(key: Resilient::Key.new("example"), properties: properties)
 
 iterations = 0
 loop do
@@ -24,10 +24,10 @@ loop do
       puts "request allowed"
       raise if rand(100) < 10
       puts "request succeeded"
-      circuit_breaker.mark_success
+      circuit_breaker.success
     rescue => boom
       puts "request failed"
-      circuit_breaker.mark_failure
+      circuit_breaker.failure
     end
   else
     puts "request denied"

data/lib/resilient.rb

@@ -2,3 +2,5 @@ require "resilient/version"
 
 module Resilient
 end
+
+require "resilient/circuit_breaker"

data/lib/resilient/circuit_breaker.rb

@@ -1,40 +1,52 @@
+require "resilient/key"
 require "resilient/circuit_breaker/metrics"
-require "resilient/circuit_breaker/config"
+require "resilient/circuit_breaker/properties"
 
 module Resilient
   class CircuitBreaker
-    attr_reader :metrics
-    attr_reader :config
+    attr_reader :key
     attr_reader :open
     attr_reader :opened_or_last_checked_at_epoch
+    attr_reader :metrics
+    attr_reader :properties
 
-    def initialize(open: false, config: Config.new, metrics: Metrics.new)
+    def initialize(key: nil, open: false, properties: nil, metrics: nil)
+      # ruby 2.0 does not support required keyword arguments, this gets around that
+      raise ArgumentError, "key argument is required" if key.nil?
+      @key = key
       @open = open
       @opened_or_last_checked_at_epoch = 0
-      @config = config
+
+      @properties = if properties
+        properties
+      else
+        Properties.new
+      end
+
       @metrics = if metrics
         metrics
       else
         Metrics.new({
-          number_of_buckets: config.number_of_buckets,
-          bucket_size_in_seconds: config.bucket_size_in_seconds,
+          window_size_in_seconds: @properties.window_size_in_seconds,
+          bucket_size_in_seconds: @properties.bucket_size_in_seconds,
         })
       end
     end
 
     def allow_request?
       default_payload = {
+        key: @key,
         force_open: false,
         force_closed: false,
       }
 
       instrument("resilient.circuit_breaker.allow_request", default_payload) { |payload|
-        result = if payload[:force_open] = @config.force_open
+        result = if payload[:force_open] = @properties.force_open
           false
         else
-          if payload[:force_closed] = @config.force_closed
+          if payload[:force_closed] = @properties.force_closed
             # we still want to simulate normal behavior/metrics like open, allow
-            # single request, etc. so it is possible to test config in
+            # single request, etc. so it is possible to test properties in
             # production without impact
             if payload[:open] = open?
               payload[:allow_single_request] = allow_single_request?
@@ -54,31 +66,40 @@ module Resilient
       }
     end
 
-    def mark_success
+    def success
       default_payload = {
+        key: @key,
         closed_the_circuit: false,
       }
 
-      instrument("resilient.circuit_breaker.mark_success", default_payload) { |payload|
+      instrument("resilient.circuit_breaker.success", default_payload) { |payload|
         if @open
           payload[:closed_the_circuit] = true
           close_circuit
         else
-          @metrics.mark_success
+          @metrics.success
         end
         nil
       }
     end
 
-    def mark_failure
-      instrument("resilient.circuit_breaker.mark_failure") { |payload|
-        @metrics.mark_failure
+    def failure
+      default_payload = {
+        key: @key,
+      }
+
+      instrument("resilient.circuit_breaker.failure", default_payload) { |payload|
+        @metrics.failure
         nil
       }
     end
 
     def reset
-      instrument("resilient.circuit_breaker.reset") { |payload|
+      default_payload = {
+        key: @key,
+      }
+
+      instrument("resilient.circuit_breaker.reset", default_payload) { |payload|
         @open = false
         @opened_or_last_checked_at_epoch = 0
         @metrics.reset
@@ -100,11 +121,11 @@ module Resilient
     end
 
     def under_request_volume_threshold?
-      @metrics.requests < @config.request_volume_threshold
+      @metrics.requests < @properties.request_volume_threshold
     end
 
     def under_error_threshold_percentage?
-      @metrics.error_percentage < @config.error_threshold_percentage
+      @metrics.error_percentage < @properties.error_threshold_percentage
     end
 
     def open?
@@ -116,14 +137,10 @@ module Resilient
       true
     end
 
-    def closed?
-      !open?
-    end
-
     def allow_single_request?
       now = Time.now.to_i
 
-      if @open && now > (@opened_or_last_checked_at_epoch + @config.sleep_window_seconds)
+      if @open && now > (@opened_or_last_checked_at_epoch + @properties.sleep_window_seconds)
         @opened_or_last_checked_at_epoch = now
         true
       else
@@ -132,7 +149,7 @@ module Resilient
     end
 
     def instrument(name, payload = {}, &block)
-      config.instrumenter.instrument(name, payload, &block)
+      properties.instrumenter.instrument(name, payload, &block)
     end
   end
 end

data/lib/resilient/circuit_breaker/metrics.rb

@@ -1,9 +1,12 @@
 require "resilient/circuit_breaker/metrics/storage/memory"
+require "resilient/circuit_breaker/metrics/bucket_range"
+require "resilient/circuit_breaker/metrics/bucket_size"
+require "resilient/circuit_breaker/metrics/window_size"
 
 module Resilient
   class CircuitBreaker
     class Metrics
-      attr_reader :number_of_buckets
+      attr_reader :window_size_in_seconds
       attr_reader :bucket_size_in_seconds
       attr_reader :buckets
       attr_reader :storage
@@ -18,78 +21,22 @@ module Resilient
 
       StorageKeys = (StorageSuccessKeys + StorageFailureKeys).freeze
 
-      class Bucket
-        attr_reader :timestamp_start
-        attr_reader :timestamp_end
-
-        def initialize(timestamp_start, timestamp_end)
-          @timestamp_start = timestamp_start
-          @timestamp_end = timestamp_end
-        end
-
-        def prune_before(number_of_buckets, bucket_size)
-          @timestamp_end - (number_of_buckets * bucket_size.seconds)
-        end
-
-        def include?(timestamp)
-          timestamp >= @timestamp_start && timestamp <= @timestamp_end
-        end
-      end
-
-      class BucketRange
-        def self.generate(timestamp, number_of_buckets, bucket_size)
-          end_bucket = bucket_size.bucket(timestamp)
-          start_bucket = bucket_size.bucket(end_bucket.prune_before(number_of_buckets, bucket_size))
-          bucket_range = new(start_bucket, end_bucket)
-        end
-
-        attr_reader :start_bucket
-        attr_reader :end_bucket
-
-        def initialize(start_bucket, end_bucket)
-          @start_bucket = start_bucket
-          @end_bucket = end_bucket
-        end
-
-        def prune?(bucket)
-          bucket.timestamp_end <= @start_bucket.timestamp_end
-        end
-      end
-
-      class BucketSize
-        attr_reader :seconds
-
-        def initialize(seconds)
-          @seconds = seconds
-        end
-
-        def aligned_start(timestamp = Time.now.to_i)
-          timestamp / @seconds * @seconds
-        end
-
-        def aligned_end(timestamp = Time.now.to_i)
-          aligned_start(timestamp) + @seconds - 1
-        end
-
-        def bucket(timestamp = Time.now.to_i)
-          Bucket.new aligned_start(timestamp), aligned_end(timestamp)
-        end
-      end
-
       def initialize(options = {})
-        @number_of_buckets = options.fetch(:number_of_buckets, 6)
-        @bucket_size = BucketSize.new(options.fetch(:bucket_size_in_seconds, 10))
+        @window_size_in_seconds = options.fetch(:window_size_in_seconds, 60)
+        @bucket_size_in_seconds = options.fetch(:bucket_size_in_seconds, 10)
+        @window_size = WindowSize.new(@window_size_in_seconds)
+        @bucket_size = BucketSize.new(@bucket_size_in_seconds)
         @storage = options.fetch(:storage) { Storage::Memory.new }
         @buckets = []
       end
 
-      def mark_success
+      def success
         @storage.increment(current_bucket, StorageSuccessKeys)
         prune_buckets
         nil
       end
 
-      def mark_failure
+      def failure
         @storage.increment(current_bucket, StorageFailureKeys)
         prune_buckets
         nil
@@ -128,7 +75,7 @@ module Resilient
       end
 
       def reset
-        @storage.reset(@buckets, StorageKeys)
+        @storage.prune(@buckets, StorageKeys)
         nil
       end
 
@@ -146,7 +93,7 @@ module Resilient
 
       def prune_buckets(timestamp = Time.now.to_i)
         pruned_buckets = []
-        bucket_range = BucketRange.generate(timestamp, @number_of_buckets, @bucket_size)
+        bucket_range = BucketRange.generate(timestamp, @window_size, @bucket_size)
 
         @buckets.delete_if { |bucket|
           if bucket_range.prune?(bucket)

data/lib/resilient/circuit_breaker/metrics/bucket.rb

@@ -0,0 +1,23 @@
+module Resilient
+  class CircuitBreaker
+    class Metrics
+      class Bucket
+        attr_reader :timestamp_start
+        attr_reader :timestamp_end
+
+        def initialize(timestamp_start, timestamp_end)
+          @timestamp_start = timestamp_start
+          @timestamp_end = timestamp_end
+        end
+
+        def prune_before(window_size)
+          @timestamp_end - window_size.seconds
+        end
+
+        def include?(timestamp)
+          timestamp >= @timestamp_start && timestamp <= @timestamp_end
+        end
+      end
+    end
+  end
+end

data/lib/resilient/circuit_breaker/metrics/bucket_range.rb

@@ -0,0 +1,25 @@
+module Resilient
+  class CircuitBreaker
+    class Metrics
+      class BucketRange
+        def self.generate(timestamp, window_size, bucket_size)
+          end_bucket = bucket_size.bucket(timestamp)
+          start_bucket = bucket_size.bucket(end_bucket.prune_before(window_size))
+          bucket_range = new(start_bucket, end_bucket)
+        end
+
+        attr_reader :start_bucket
+        attr_reader :end_bucket
+
+        def initialize(start_bucket, end_bucket)
+          @start_bucket = start_bucket
+          @end_bucket = end_bucket
+        end
+
+        def prune?(bucket)
+          bucket.timestamp_end <= @start_bucket.timestamp_end
+        end
+      end
+    end
+  end
+end

data/lib/resilient/circuit_breaker/metrics/bucket_size.rb

@@ -0,0 +1,27 @@
+require "resilient/circuit_breaker/metrics/bucket"
+
+module Resilient
+  class CircuitBreaker
+    class Metrics
+      class BucketSize
+        attr_reader :seconds
+
+        def initialize(seconds)
+          @seconds = seconds
+        end
+
+        def aligned_start(timestamp = Time.now.to_i)
+          timestamp / @seconds * @seconds
+        end
+
+        def aligned_end(timestamp = Time.now.to_i)
+          aligned_start(timestamp) + @seconds - 1
+        end
+
+        def bucket(timestamp = Time.now.to_i)
+          Bucket.new aligned_start(timestamp), aligned_end(timestamp)
+        end
+      end
+    end
+  end
+end

data/lib/resilient/circuit_breaker/metrics/storage/memory.rb

@@ -17,16 +17,6 @@ module Resilient
             end
           end
 
-          def get(buckets, keys)
-            result = Hash.new { |h, k| h[k] = Hash.new(0) }
-            Array(buckets).each do |bucket|
-              Array(keys).each do |key|
-                result[bucket][key] = @source[bucket][key]
-              end
-            end
-            result
-          end
-
           def sum(buckets, keys)
             response = Hash.new(0)
             Array(buckets).each do |bucket|
@@ -37,15 +27,11 @@ module Resilient
             response
           end
 
-          def reset(buckets, keys)
+          def prune(buckets, keys)
             Array(buckets).each do |bucket|
               @source.delete(bucket)
             end
           end
-
-          def prune(buckets, keys)
-            reset(buckets, keys)
-          end
         end
       end
     end

data/lib/resilient/circuit_breaker/metrics/window_size.rb

@@ -0,0 +1,15 @@
+require "resilient/circuit_breaker/metrics/bucket"
+
+module Resilient
+  class CircuitBreaker
+    class Metrics
+      class WindowSize
+        attr_reader :seconds
+
+        def initialize(seconds)
+          @seconds = seconds
+        end
+      end
+    end
+  end
+end

data/lib/resilient/circuit_breaker/properties.rb

@@ -0,0 +1,56 @@
+require "resilient/instrumenters/noop"
+
+module Resilient
+  class CircuitBreaker
+    class Properties
+      # allows forcing the circuit open (stopping all requests)
+      attr_reader :force_open
+
+      # allows ignoring errors and therefore never trip "open"
+      # (ie. allow all traffic through); normal instrumentation will still
+      # happen, thus allowing you to "test" configuration live without impact
+      attr_reader :force_closed
+
+      # what to use to instrument all events that happen
+      # (ie: ActiveSupport::Notifications)
+      attr_reader :instrumenter
+
+      # seconds after tripping circuit before allowing retry
+      attr_reader :sleep_window_seconds
+
+      # number of requests that must be made within a statistical window before
+      # open/close decisions are made using stats
+      attr_reader :request_volume_threshold
+
+      # % of "marks" that must be failed to trip the circuit
+      attr_reader :error_threshold_percentage
+
+      # number of seconds in the statistical window
+      attr_reader :window_size_in_seconds
+
+      # size of buckets in statistical window
+      attr_reader :bucket_size_in_seconds
+
+      def initialize(options = {})
+        @force_open = options.fetch(:force_open, false)
+        @force_closed = options.fetch(:force_closed, false)
+        @instrumenter = options.fetch(:instrumenter, Instrumenters::Noop)
+        @sleep_window_seconds = options.fetch(:sleep_window_seconds, 5)
+        @request_volume_threshold = options.fetch(:request_volume_threshold, 20)
+        @error_threshold_percentage = options.fetch(:error_threshold_percentage, 50)
+        @window_size_in_seconds = options.fetch(:window_size_in_seconds, 60)
+        @bucket_size_in_seconds = options.fetch(:bucket_size_in_seconds, 10)
+
+        if @bucket_size_in_seconds >= @window_size_in_seconds
+          raise ArgumentError, "bucket_size_in_seconds must be smaller than window_size_in_seconds"
+        end
+
+        if @window_size_in_seconds % @bucket_size_in_seconds != 0
+          raise ArgumentError,
+            "window_size_in_seconds must be perfectly divisible by" +
+            " bucket_size_in_seconds in order to evenly partition the buckets"
+        end
+      end
+    end
+  end
+end

data/lib/resilient/key.rb

@@ -0,0 +1,9 @@
+module Resilient
+  class Key
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+  end
+end

data/lib/resilient/test/circuit_breaker_interface.rb

@@ -1,30 +1,33 @@
 module Resilient
   class Test
     module CircuitBreakerInterface
+      def test_responds_to_key
+        assert_respond_to @object, :key
+      end
+
       def test_responds_to_allow_request
         assert_respond_to @object, :allow_request?
       end
 
-      def test_responds_to_mark_success
-        assert_respond_to @object, :mark_success
+      def test_responds_to_success
+        assert_respond_to @object, :success
       end
 
-      def test_mark_success_returns_nothing
-        assert_nil @object.mark_success
+      def test_success_returns_nothing
+        assert_nil @object.success
       end
 
-      def test_responds_to_mark_failure
-        assert_respond_to @object, :mark_failure
+      def test_responds_to_failure
+        assert_respond_to @object, :failure
       end
 
-      def test_mark_failure_returns_nothing
-        assert_nil @object.mark_failure
+      def test_failure_returns_nothing
+        assert_nil @object.failure
       end
 
       def test_responds_to_reset
         assert_respond_to @object, :reset
       end
     end
-
   end
 end

data/lib/resilient/test/metrics_interface.rb

@@ -1,20 +1,20 @@
 module Resilient
   class Test
     module MetricsInterface
-      def test_responds_to_mark_success
-        assert_respond_to @object, :mark_success
+      def test_responds_to_success
+        assert_respond_to @object, :success
       end
 
-      def test_mark_success_returns_nothing
-        assert_nil @object.mark_success
+      def test_success_returns_nothing
+        assert_nil @object.success
       end
 
-      def test_responds_to_mark_failure
-        assert_respond_to @object, :mark_failure
+      def test_responds_to_failure
+        assert_respond_to @object, :failure
       end
 
-      def test_mark_failure_returns_nothing
-        assert_nil @object.mark_failure
+      def test_failure_returns_nothing
+        assert_nil @object.failure
       end
 
       def test_responds_to_successes

data/lib/resilient/test/metrics_storage_interface.rb

@@ -5,10 +5,6 @@ module Resilient
         assert_respond_to @object, :increment
       end
 
-      def test_responds_to_get
-        assert_respond_to @object, :get
-      end
-
       def test_responds_to_sum
         assert_respond_to @object, :sum
       end
@@ -17,10 +13,6 @@ module Resilient
         assert_respond_to @object, :prune
       end
 
-      def test_responds_to_reset
-        assert_respond_to @object, :reset
-      end
-
       def test_increment
         buckets = [
           Resilient::CircuitBreaker::Metrics::Bucket.new(1, 5),
@@ -37,7 +29,7 @@ module Resilient
         assert_equal 1, @object.source[buckets[1]][:failures]
       end
 
-      def test_get_defaults
+      def test_sum_defaults
         buckets = [
           Resilient::CircuitBreaker::Metrics::Bucket.new(1, 5),
           Resilient::CircuitBreaker::Metrics::Bucket.new(6, 10),
@@ -46,33 +38,12 @@ module Resilient
           :successes,
           :failures,
         ]
-        result = @object.get(buckets, keys)
-        assert_equal 0, result[buckets[0]][:successes]
-        assert_equal 0, result[buckets[0]][:failures]
-        assert_equal 0, result[buckets[1]][:successes]
-        assert_equal 0, result[buckets[1]][:failures]
-      end
-
-      def test_get_with_values
-        buckets = [
-          Resilient::CircuitBreaker::Metrics::Bucket.new(1, 5),
-          Resilient::CircuitBreaker::Metrics::Bucket.new(6, 10),
-        ]
-        keys = [
-          :successes,
-          :failures,
-        ]
-        @object.increment(buckets, keys)
-        @object.increment(buckets, keys)
-        @object.increment(buckets[0], keys)
-        result = @object.get(buckets, keys)
-        assert_equal 3, result[buckets[0]][:successes]
-        assert_equal 3, result[buckets[0]][:failures]
-        assert_equal 2, result[buckets[1]][:successes]
-        assert_equal 2, result[buckets[1]][:failures]
+        result = @object.sum(buckets, keys)
+        assert_equal 0, result[:successes]
+        assert_equal 0, result[:failures]
       end
 
-      def test_sum
+      def test_sum_with_values
         buckets = [
           Resilient::CircuitBreaker::Metrics::Bucket.new(1, 5),
           Resilient::CircuitBreaker::Metrics::Bucket.new(6, 10),
@@ -98,26 +69,6 @@ module Resilient
         assert_equal 4, @object.sum(buckets[1], keys).values.inject(0) { |sum, value| sum += value }
       end
 
-      def test_reset
-        buckets = [
-          Resilient::CircuitBreaker::Metrics::Bucket.new(1, 5),
-          Resilient::CircuitBreaker::Metrics::Bucket.new(6, 10),
-        ]
-        keys = [
-          :successes,
-          :failures,
-        ]
-        @object.increment(buckets, keys)
-        @object.increment(buckets, keys)
-        @object.increment(buckets[0], keys)
-        @object.reset(buckets, keys)
-        result = @object.get(buckets, keys)
-        assert_equal 0, result[buckets[0]][:successes]
-        assert_equal 0, result[buckets[0]][:failures]
-        assert_equal 0, result[buckets[1]][:successes]
-        assert_equal 0, result[buckets[1]][:failures]
-      end
-
       def test_prune
         buckets = [
           Resilient::CircuitBreaker::Metrics::Bucket.new(1, 5),
@@ -131,11 +82,9 @@ module Resilient
         @object.increment(buckets, keys)
         @object.increment(buckets[0], keys)
         @object.prune(buckets, keys)
-        result = @object.get(buckets, keys)
-        assert_equal 0, result[buckets[0]][:successes]
-        assert_equal 0, result[buckets[0]][:failures]
-        assert_equal 0, result[buckets[1]][:successes]
-        assert_equal 0, result[buckets[1]][:failures]
+        result = @object.sum(buckets, keys)
+        assert_equal 0, result[:successes]
+        assert_equal 0, result[:failures]
       end
     end
   end

data/lib/resilient/test/{config_interface.rb → properties_interface.rb}

@@ -1,6 +1,6 @@
 module Resilient
   class Test
-    module ConfigInterface
+    module PropertiesInterface
       def test_responds_to_force_open
         assert_respond_to @object, :force_open
       end
@@ -25,10 +25,6 @@ module Resilient
         assert_respond_to @object, :error_threshold_percentage
       end
 
-      def test_responds_to_number_of_buckets
-        assert_respond_to @object, :number_of_buckets
-      end
-
       def test_responds_to_bucket_size_in_seconds
         assert_respond_to @object, :bucket_size_in_seconds
       end

data/lib/resilient/version.rb

@@ -1,3 +1,3 @@
 module Resilient
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/resilient.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'resilient/version'
+require "resilient/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "resilient"
@@ -19,6 +19,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.8"
+  spec.add_development_dependency "timecop", "~> 0.8.0"
 end

data/script/bootstrap

@@ -1 +1,15 @@
+#!/bin/sh
+#/ Usage: bootstrap
+#/
+#/ Get the dependencies needed to work on the gem.
+#/
+
+set -e
+cd $(dirname "$0")/..
+
+[ "$1" = "--help" -o "$1" = "-h" -o "$1" = "help" ] && {
+    grep '^#/' <"$0"| cut -c4-
+    exit 0
+}
+
 bundle --quiet

data/script/watch

@@ -1 +1,15 @@
+#!/bin/sh
+#/ Usage: watch
+#/
+#/ Startup guard.
+#/
+
+set -e
+cd $(dirname "$0")/..
+
+[ "$1" = "--help" -o "$1" = "-h" -o "$1" = "help" ] && {
+    grep '^#/' <"$0"| cut -c4-
+    exit 0
+}
+
 bundle exec guard

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resilient
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - John Nunemaker
@@ -14,44 +14,44 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.10'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '5.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '5.8'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '5.8'
+        version: 0.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '5.8'
+        version: 0.8.0
 description: 
 email:
 - nunemaker@gmail.com
@@ -59,26 +59,30 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
+- .travis.yml
 - Gemfile
 - Guardfile
 - LICENSE.txt
 - README.md
-- Rakefile
 - examples/basic.rb
 - examples/long_running.rb
 - lib/resilient.rb
 - lib/resilient/circuit_breaker.rb
-- lib/resilient/circuit_breaker/config.rb
 - lib/resilient/circuit_breaker/metrics.rb
+- lib/resilient/circuit_breaker/metrics/bucket.rb
+- lib/resilient/circuit_breaker/metrics/bucket_range.rb
+- lib/resilient/circuit_breaker/metrics/bucket_size.rb
 - lib/resilient/circuit_breaker/metrics/storage/memory.rb
+- lib/resilient/circuit_breaker/metrics/window_size.rb
+- lib/resilient/circuit_breaker/properties.rb
 - lib/resilient/instrumenters/memory.rb
 - lib/resilient/instrumenters/noop.rb
+- lib/resilient/key.rb
 - lib/resilient/test/circuit_breaker_interface.rb
-- lib/resilient/test/config_interface.rb
 - lib/resilient/test/metrics_interface.rb
 - lib/resilient/test/metrics_storage_interface.rb
+- lib/resilient/test/properties_interface.rb
 - lib/resilient/version.rb
 - resilient.gemspec
 - script/bootstrap
@@ -96,17 +100,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: toolkit for resilient ruby apps

data/Rakefile

@@ -1,10 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList['test/**/*_test.rb']
-end
-
-task :default => :test

data/lib/resilient/circuit_breaker/config.rb

@@ -1,27 +0,0 @@
-require "resilient/instrumenters/noop"
-
-module Resilient
-  class CircuitBreaker
-    class Config
-      attr_reader :force_open
-      attr_reader :force_closed
-      attr_reader :instrumenter
-      attr_reader :sleep_window_seconds
-      attr_reader :request_volume_threshold
-      attr_reader :error_threshold_percentage
-      attr_reader :number_of_buckets
-      attr_reader :bucket_size_in_seconds
-
-      def initialize(options = {})
-        @force_open = options.fetch(:force_open, false)
-        @force_closed = options.fetch(:force_closed, false)
-        @instrumenter = options.fetch(:instrumenter, Instrumenters::Noop)
-        @sleep_window_seconds = options.fetch(:sleep_window_seconds, 5)
-        @request_volume_threshold = options.fetch(:request_volume_threshold, 20)
-        @error_threshold_percentage = options.fetch(:error_threshold_percentage, 50)
-        @number_of_buckets = options.fetch(:number_of_buckets, 6)
-        @bucket_size_in_seconds = options.fetch(:bucket_size_in_seconds, 10)
-      end
-    end
-  end
-end